openrewrite-migrate-python 0.9.0.dev20260606102208__tar.gz → 0.9.0.dev20260606181158__tar.gz

{openrewrite_migrate_python-0.9.0.dev20260606102208 → openrewrite_migrate_python-0.9.0.dev20260606181158}/PKG-INFO

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

{openrewrite_migrate_python-0.9.0.dev20260606102208 → openrewrite_migrate_python-0.9.0.dev20260606181158}/src/openrewrite_migrate_python/migrate/typing_union_to_pipe.py

@@ -17,6 +17,7 @@ from rewrite.category import CategoryDescriptor
 from rewrite.decorators import categorize
 from rewrite.marketplace import Python
 from rewrite.markers import Markers
+from rewrite.python.remove_import import RemoveImportOptions, maybe_remove_import
 from rewrite.python.visitor import PythonVisitor
 from rewrite.java.support_types import JRightPadded, Space
 from rewrite.java.tree import (
@@ -168,6 +169,11 @@ class ReplaceTypingOptionalWithUnion(Recipe):
 
                 type_arg = type_params[0]
 
+                # Drop the now-unused `from typing import Optional` (kept if still used)
+                maybe_remove_import(
+                    self, RemoveImportOptions(module="typing", name="Optional")
+                )
+
                 # Create X | None using UnionType
                 none_literal = _create_none_literal(Space.EMPTY)
                 return _create_union_type([type_arg, none_literal], param_type.prefix)
@@ -184,6 +190,11 @@ class ReplaceTypingOptionalWithUnion(Recipe):
                 # Get the type argument from the dimension
                 index = array_access.dimension.index
 
+                # Drop the now-unused `from typing import Optional` (kept if still used)
+                maybe_remove_import(
+                    self, RemoveImportOptions(module="typing", name="Optional")
+                )
+
                 # Create X | None using UnionType
                 none_literal = _create_none_literal(Space.EMPTY)
                 return _create_union_type([index, none_literal], array_access.prefix)
@@ -243,6 +254,11 @@ class ReplaceTypingUnionWithPipe(Recipe):
                 if type_params is None or len(type_params) < 2:
                     return param_type
 
+                # Drop the now-unused `from typing import Union` (kept if still used)
+                maybe_remove_import(
+                    self, RemoveImportOptions(module="typing", name="Union")
+                )
+
                 # Create union type with all type parameters
                 return _create_union_type(list(type_params), param_type.prefix)
 
@@ -266,6 +282,11 @@ class ReplaceTypingUnionWithPipe(Recipe):
                 if len(elements) < 2:
                     return array_access
 
+                # Drop the now-unused `from typing import Union` (kept if still used)
+                maybe_remove_import(
+                    self, RemoveImportOptions(module="typing", name="Union")
+                )
+
                 # Create union type with all elements
                 return _create_union_type(elements, array_access.prefix)
 

{openrewrite_migrate_python-0.9.0.dev20260606102208 → openrewrite_migrate_python-0.9.0.dev20260606181158}/src/openrewrite_migrate_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrewrite-migrate-python
-Version: 0.9.0.dev20260606102208
+Version: 0.9.0.dev20260606181158
 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.9.0.dev20260606102208 → openrewrite_migrate_python-0.9.0.dev20260606181158}/tests/test_typing_union_to_pipe.py

@@ -11,54 +11,47 @@ class TestReplaceTypingOptionalWithUnion:
     """Tests for the ReplaceTypingOptionalWithUnion recipe."""
 
     def test_replaces_optional_simple_type(self):
-        """Test replacing Optional[str] with str | None."""
+        """Test replacing Optional[str] with str | None and removing the import."""
         spec = RecipeSpec(recipe=ReplaceTypingOptionalWithUnion())
         spec.rewrite_run(
             python(
                 """
                 from typing import Optional
-
                 name: Optional[str] = None
                 """,
                 """
-                from typing import Optional
-
                 name: str | None = None
                 """,
             )
         )
 
     def test_replaces_optional_complex_type(self):
-        """Test replacing Optional with a complex type argument."""
+        """Test replacing Optional with a complex type argument; keep still-used import."""
         spec = RecipeSpec(recipe=ReplaceTypingOptionalWithUnion())
         spec.rewrite_run(
             python(
                 """
                 from typing import Optional, List
-
                 items: Optional[List[int]] = None
                 """,
                 """
-                from typing import Optional, List
-
+                from typing import List
                 items: List[int] | None = None
                 """,
             )
         )
 
     def test_replaces_typing_dot_optional(self):
-        """Test replacing typing.Optional[X] (fully qualified)."""
+        """Test replacing typing.Optional[X] (fully qualified); import typing kept."""
         spec = RecipeSpec(recipe=ReplaceTypingOptionalWithUnion())
         spec.rewrite_run(
             python(
                 """
                 import typing
-
                 name: typing.Optional[str] = None
                 """,
                 """
                 import typing
-
                 name: str | None = None
                 """,
             )
@@ -71,12 +64,29 @@ class TestReplaceTypingOptionalWithUnion:
             python(
                 """
                 from typing import List
-
                 items: List[str] = []
                 """
             )
         )
 
+    def test_keeps_import_when_optional_still_used(self):
+        """Test that the import is kept when Optional is still referenced elsewhere."""
+        spec = RecipeSpec(recipe=ReplaceTypingOptionalWithUnion())
+        spec.rewrite_run(
+            python(
+                """
+                from typing import Optional
+                alias = Optional
+                name: Optional[str] = None
+                """,
+                """
+                from typing import Optional
+                alias = Optional
+                name: str | None = None
+                """,
+            )
+        )
+
     def test_replaces_optional_in_return_type(self):
         """Test replacing Optional in function return types."""
         spec = RecipeSpec(recipe=ReplaceTypingOptionalWithUnion())
@@ -84,13 +94,10 @@ class TestReplaceTypingOptionalWithUnion:
             python(
                 """
                 from typing import Optional
-
                 def process() -> Optional[int]:
                     return None
                 """,
                 """
-                from typing import Optional
-
                 def process() -> int | None:
                     return None
                 """,
@@ -104,13 +111,10 @@ class TestReplaceTypingOptionalWithUnion:
             python(
                 """
                 from typing import Optional
-
                 def process(name: Optional[str]) -> Optional[int]:
                     return None
                 """,
                 """
-                from typing import Optional
-
                 def process(name: str | None) -> int | None:
                     return None
                 """,
@@ -122,18 +126,15 @@ class TestReplaceTypingUnionWithPipe:
     """Tests for the ReplaceTypingUnionWithPipe recipe."""
 
     def test_replaces_union_two_types(self):
-        """Test replacing Union[int, str] with int | str."""
+        """Test replacing Union[int, str] with int | str and removing the import."""
         spec = RecipeSpec(recipe=ReplaceTypingUnionWithPipe())
         spec.rewrite_run(
             python(
                 """
                 from typing import Union
-
                 value: Union[int, str] = 0
                 """,
                 """
-                from typing import Union
-
                 value: int | str = 0
                 """,
             )
@@ -146,30 +147,25 @@ class TestReplaceTypingUnionWithPipe:
             python(
                 """
                 from typing import Union
-
                 value: Union[int, str, float] = 0
                 """,
                 """
-                from typing import Union
-
                 value: int | str | float = 0
                 """,
             )
         )
 
     def test_replaces_typing_dot_union(self):
-        """Test replacing typing.Union[X, Y] (fully qualified)."""
+        """Test replacing typing.Union[X, Y] (fully qualified); import typing kept."""
         spec = RecipeSpec(recipe=ReplaceTypingUnionWithPipe())
         spec.rewrite_run(
             python(
                 """
                 import typing
-
                 value: typing.Union[int, str] = 0
                 """,
                 """
                 import typing
-
                 value: int | str = 0
                 """,
             )
@@ -182,12 +178,47 @@ class TestReplaceTypingUnionWithPipe:
             python(
                 """
                 from typing import List
-
                 items: List[str] = []
                 """
             )
         )
 
+    def test_keeps_import_when_union_still_used(self):
+        """Test that the import is kept when Union is still referenced elsewhere."""
+        spec = RecipeSpec(recipe=ReplaceTypingUnionWithPipe())
+        spec.rewrite_run(
+            python(
+                """
+                from typing import Union
+                alias = Union
+                value: Union[int, str] = 0
+                """,
+                """
+                from typing import Union
+                alias = Union
+                value: int | str = 0
+                """,
+            )
+        )
+
+    def test_keeps_other_imports_when_removing_union(self):
+        """Test partial removal: only Union is dropped, other names are kept."""
+        spec = RecipeSpec(recipe=ReplaceTypingUnionWithPipe())
+        spec.rewrite_run(
+            python(
+                """
+                from typing import Union, List
+                value: Union[int, str] = 0
+                items: List[int] = []
+                """,
+                """
+                from typing import List
+                value: int | str = 0
+                items: List[int] = []
+                """,
+            )
+        )
+
     def test_replaces_union_in_return_type(self):
         """Test replacing Union in function return types."""
         spec = RecipeSpec(recipe=ReplaceTypingUnionWithPipe())
@@ -195,13 +226,10 @@ class TestReplaceTypingUnionWithPipe:
             python(
                 """
                 from typing import Union
-
                 def process() -> Union[str, None]:
                     return None
                 """,
                 """
-                from typing import Union
-
                 def process() -> str | None:
                     return None
                 """,
@@ -215,13 +243,10 @@ class TestReplaceTypingUnionWithPipe:
             python(
                 """
                 from typing import Union
-
                 def process(value: Union[int, str]) -> Union[str, None]:
                     return str(value)
                 """,
                 """
-                from typing import Union
-
                 def process(value: int | str) -> str | None:
                     return str(value)
                 """,