openrewrite-migrate-python 0.14.0.dev20260902123950__tar.gz → 0.14.0.dev20260902131752__tar.gz

{openrewrite_migrate_python-0.14.0.dev20260902123950 → openrewrite_migrate_python-0.14.0.dev20260902131752}/PKG-INFO

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

{openrewrite_migrate_python-0.14.0.dev20260902123950 → openrewrite_migrate_python-0.14.0.dev20260902131752}/src/openrewrite_migrate_python/migrate/typing_deprecations.py

@@ -23,26 +23,39 @@ See: https://peps.python.org/pep-0585/
 import ast
 from typing import Any, ClassVar, Optional, Set, cast
 
-from rewrite import ExecutionContext, Recipe, TreeVisitor
+from rewrite import ExecutionContext, Recipe, Tree, TreeVisitor
 from rewrite.category import CategoryDescriptor
 from rewrite.decorators import categorize
 from rewrite.marketplace import Python
 from rewrite.python.markers import Quoted
 from rewrite.python.scope_utils import LocalBindings
+from rewrite.visitor import Cursor
 
 from ._typing_imports import (
     maybe_remove_typing_import,
     maybe_remove_typing_module_import,
     scan_typing_imports,
 )
-from rewrite.python.tree import CompilationUnit, MultiImport, NamedArgument
+from rewrite.python.tree import (
+    CollectionLiteral,
+    CompilationUnit,
+    MultiImport,
+    NamedArgument,
+    TypeAlias,
+    TypeHint,
+    TypeHintedExpression,
+)
 from rewrite.python.visitor import PythonVisitor
 from rewrite.java.tree import (
+    ArrayAccess,
+    Assignment,
     FieldAccess,
     Identifier,
     Import,
     J,
     Literal,
+    ParameterizedType,
+    VariableDeclarations,
 )
 
 # Define category paths
@@ -59,7 +72,72 @@ _Python311 = [
 ]
 
 
-def _make_builtin_alias_editor(old_name: str, new_name: str) -> "TreeVisitor[Any, ExecutionContext]":
+def _bound_name(expr: Optional[Tree]) -> Optional[str]:
+    """The name ``expr`` refers to, for a bare or module-qualified reference."""
+    if isinstance(expr, FieldAccess):
+        expr = expr.name
+    return expr.simple_name if isinstance(expr, Identifier) else None
+
+
+def _names_type_alias(target: J) -> bool:
+    """True for the `X: TypeAlias` target of an explicit type-alias assignment."""
+    if not isinstance(target, TypeHintedExpression):
+        return False
+    return _bound_name(target.type_hint.type_tree) == "TypeAlias"
+
+
+def _annotated_type_argument(subscript: Tree) -> Optional[J]:
+    """The lone type argument of an `Annotated[...]`, or None for another subscript.
+
+    The parser spells a subscript as `ParameterizedType` where it expects a type
+    and as `ArrayAccess` elsewhere; both reach here.
+    """
+    if isinstance(subscript, ParameterizedType):
+        target, arguments = subscript.clazz, subscript.type_parameters
+    elif isinstance(subscript, ArrayAccess):
+        index = subscript.dimension.index
+        target = subscript.indexed
+        arguments = index.elements if isinstance(index, CollectionLiteral) else [index]
+    else:
+        return None
+    if _bound_name(target) != "Annotated" or not arguments:
+        return None
+    return arguments[0]
+
+
+def _in_annotation(cursor: Cursor) -> bool:
+    """True when the cursor's node stands where a type expression is expected.
+
+    Annotations are the only position where a `typing` alias and its built-in
+    are interchangeable; elsewhere they are distinct objects, so a dict key or
+    a call argument spelling the alias must keep naming it.
+    """
+    walked = [cursor.value]
+    parent_cursor = cursor.parent_tree_cursor()
+    while isinstance(parent_cursor.value, Tree):
+        parent = parent_cursor.value
+        child = walked[-1]
+        if isinstance(parent, TypeHint):
+            return True
+        if isinstance(parent, VariableDeclarations):
+            return parent.type_expression is child
+        if isinstance(parent, TypeAlias):
+            return parent.value is child
+        if isinstance(parent, Assignment):
+            return parent.assignment is child and _names_type_alias(parent.variable)
+        # `Annotated` carries a type in its first argument and runtime metadata
+        # in the rest, which a tuple wraps a level below the subscript.
+        annotated_type = _annotated_type_argument(parent)
+        if annotated_type is not None and not any(node is annotated_type for node in walked):
+            return False
+        walked.append(parent)
+        parent_cursor = parent_cursor.parent_tree_cursor()
+    return False
+
+
+def _make_builtin_alias_editor(
+    old_name: str, new_name: str, annotations_only: bool
+) -> "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:
@@ -69,6 +147,9 @@ def _make_builtin_alias_editor(old_name: str, new_name: str) -> "TreeVisitor[Any
     - ``import typing [as alias]`` plus qualified ``typing.<old_name>``
       attribute references
 
+    ``annotations_only`` confines the rename to annotation context
+    (see `_in_annotation`).
+
     Import removal is delegated to the SDK's `RemoveImport`, which only
     removes imports that are no longer referenced and preserves comments.
     """
@@ -160,6 +241,7 @@ def _make_builtin_alias_editor(old_name: str, new_name: str) -> "TreeVisitor[Any
                 isinstance(field_access.target, Identifier)
                 and field_access.target.simple_name in self._module_refs
                 and field_access.name.simple_name == old_name
+                and (not annotations_only or _in_annotation(self.cursor))
             ):
                 self._rewrote_qualified = True
                 return field_access.name.replace(_simple_name=new_name).replace(
@@ -190,6 +272,8 @@ def _make_builtin_alias_editor(old_name: str, new_name: str) -> "TreeVisitor[Any
             # A name bound by an enclosing scope is that local, not the import.
             if self._local_bindings.is_bound(self.cursor, self._bare_ref):
                 return ident
+            if annotations_only and not _in_annotation(self.cursor):
+                return ident
 
             return ident.replace(_simple_name=new_name)
 
@@ -201,6 +285,8 @@ class _ReplaceTypingAliasRecipe(Recipe):
 
     old_name: ClassVar[str]
     new_name: ClassVar[str]
+    # False only where the alias *is* the built-in, so any position is safe.
+    annotations_only: ClassVar[bool] = True
 
     @property
     def name(self) -> str:
@@ -217,14 +303,17 @@ class _ReplaceTypingAliasRecipe(Recipe):
     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. "
+            f"Replace with the built-in `{self.new_name}` type in annotations. "
             "Applies inside `if TYPE_CHECKING:` blocks as well; the built-in generic is "
             "valid at runtime from Python 3.9 on, so no `from __future__ import "
-            "annotations` is needed."
+            "annotations` is needed. "
+            f"References outside an annotation are left alone: `typing.{self.old_name}` "
+            f"and `{self.new_name}` are distinct objects, so substituting one for the "
+            "other where the name is used as a value would change behaviour."
         )
 
     def editor(self) -> TreeVisitor[Any, ExecutionContext]:
-        return _make_builtin_alias_editor(self.old_name, self.new_name)
+        return _make_builtin_alias_editor(self.old_name, self.new_name, self.annotations_only)
 
 
 @categorize(_Python39)
@@ -354,6 +443,7 @@ class ReplaceTypingText(_ReplaceTypingAliasRecipe):
 
     old_name = "Text"
     new_name = "str"
+    annotations_only = False
 
     @property
     def name(self) -> str:

{openrewrite_migrate_python-0.14.0.dev20260902123950 → openrewrite_migrate_python-0.14.0.dev20260902131752}/src/openrewrite_migrate_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrewrite-migrate-python
-Version: 0.14.0.dev20260902123950
+Version: 0.14.0.dev20260902131752
 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.14.0.dev20260902123950 → openrewrite_migrate_python-0.14.0.dev20260902131752}/tests/test_typing_deprecations.py

@@ -508,6 +508,82 @@ class TestPep585CornerCases:
             )
         )
 
+    def test_leaves_value_positions_alone(self):
+        """`typing.List` is a distinct object from `list`, so only annotations may change."""
+        spec = RecipeSpec(recipe=ReplaceTypingListWithList())
+        spec.rewrite_run(
+            python(
+                """
+                import typing
+                from typing import List
+
+                SEQUENCE_ORIGIN_MAP = {list: list, typing.List: list, List: list}
+                alias = List
+
+
+                def build(items: List[int], factory=List):
+                    return factory()
+                """,
+                """
+                import typing
+                from typing import List
+
+                SEQUENCE_ORIGIN_MAP = {list: list, typing.List: list, List: list}
+                alias = List
+
+
+                def build(items: list[int], factory=List):
+                    return factory()
+                """,
+            )
+        )
+
+    def test_leaves_annotated_metadata_alone(self):
+        """Only `Annotated`'s first argument is a type; the rest are runtime values."""
+        spec = RecipeSpec(recipe=ReplaceTypingListWithList())
+        spec.rewrite_run(
+            python(
+                """
+                from typing import Annotated, List
+
+                x: Annotated[List[int], List] = []
+
+
+                def f() -> Annotated[List[int], List]:
+                    return x
+                """,
+                """
+                from typing import Annotated, List
+
+                x: Annotated[list[int], List] = []
+
+
+                def f() -> Annotated[list[int], List]:
+                    return x
+                """,
+            )
+        )
+
+    def test_rewrites_a_type_alias_right_hand_side(self):
+        """A `TypeAlias` right-hand side is an annotation, not a value."""
+        spec = RecipeSpec(recipe=ReplaceTypingListWithList())
+        spec.rewrite_run(
+            python(
+                """
+                from typing import List, TypeAlias
+
+                Names: TypeAlias = List[str]
+                type Counts = List[int]
+                """,
+                """
+                from typing import TypeAlias
+
+                Names: TypeAlias = list[str]
+                type Counts = list[int]
+                """,
+            )
+        )
+
     def test_preserves_comment_on_removed_import(self):
         spec = RecipeSpec(recipe=ReplaceTypingListWithList())
         spec.rewrite_run(
@@ -570,6 +646,22 @@ class TestReplaceTypingText:
             )
         )
 
+    def test_rewrites_text_in_a_value_position(self):
+        """`typing.Text` is `str`, so the substitution holds outside annotations too."""
+        spec = RecipeSpec(recipe=ReplaceTypingText())
+        spec.rewrite_run(
+            python(
+                """
+                from typing import Text
+
+                COLUMN_TYPES = {Text: "text"}
+                """,
+                """
+                COLUMN_TYPES = {str: "text"}
+                """,
+            )
+        )
+
     def test_no_change_when_text_from_other_module(self):
         """A `Text` imported from another module must not be touched."""
         spec = RecipeSpec(recipe=ReplaceTypingText())