openrewrite-migrate-python 0.14.0.dev20260909084854__tar.gz → 0.14.0.dev20260909112655__tar.gz

{openrewrite_migrate_python-0.14.0.dev20260909084854 → openrewrite_migrate_python-0.14.0.dev20260909112655}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrewrite-migrate-python
-Version: 0.14.0.dev20260909084854
+Version: 0.14.0.dev20260909112655
 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.dev20260909084854 → openrewrite_migrate_python-0.14.0.dev20260909112655}/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.dev20260909084854"  # Updated dynamically during release
+version = "0.14.0.dev20260909112655"  # 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.dev20260909084854 → openrewrite_migrate_python-0.14.0.dev20260909112655}/src/openrewrite_migrate_python/migrate/typing_deprecations.py

@@ -20,12 +20,15 @@ handled with `ChangeImport` in `upgrade_to_python39`.
 See: https://peps.python.org/pep-0585/
 """
 
+import ast
 from typing import Any, ClassVar, Optional, Set, cast
 
 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.import_utils import referenced_names
+from rewrite.python.markers import Quoted
 from rewrite.python.scope_utils import LocalBindings
 from rewrite.visitor import Cursor
 
@@ -37,6 +40,7 @@ from ._typing_imports import (
 from rewrite.python.tree import (
     CollectionLiteral,
     CompilationUnit,
+    ExpressionTypeTree,
     MultiImport,
     NamedArgument,
     TypeAlias,
@@ -47,11 +51,13 @@ from rewrite.python.visitor import PythonVisitor
 from rewrite.java.tree import (
     ArrayAccess,
     Assignment,
+    ClassDeclaration,
     FieldAccess,
     Identifier,
     Import,
     J,
     ParameterizedType,
+    TypeParameter,
     VariableDeclarations,
 )
 
@@ -102,12 +108,12 @@ def _annotated_type_argument(subscript: Tree) -> Optional[J]:
     return arguments[0]
 
 
-def _in_annotation(cursor: Cursor) -> bool:
+def _in_type_position(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.
+    A type position is the only one 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()
@@ -122,6 +128,16 @@ def _in_annotation(cursor: Cursor) -> bool:
             return parent.value is child
         if isinstance(parent, Assignment):
             return parent.assignment is child and _names_type_alias(parent.variable)
+        # A type parameter's bound, constraint tuple and PEP 696 default are
+        # types; its name is the type parameter being declared.
+        if isinstance(parent, TypeParameter):
+            return parent.name is not child
+        # `implements` holds the base list, where an `ExpressionTypeTree` wraps
+        # a keyword argument or a computed base rather than a type.
+        if isinstance(parent, ClassDeclaration):
+            return not isinstance(child, ExpressionTypeTree) and any(
+                base is child for base in (parent.implements or [])
+            )
         # `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)
@@ -132,8 +148,46 @@ def _in_annotation(cursor: Cursor) -> bool:
     return False
 
 
+def _rename_in_quoted_body(body: str, old_name: str, new_name: str) -> Optional[str]:
+    """`body` with each name lookup of `old_name` renamed, or None when it holds none.
+
+    A quoted annotation carries a whole expression in one identifier, so the
+    rename has to land on its `ast.Name` nodes. Only parsing separates those
+    from a string constant the body encloses, where the name is a value:
+    renaming in `Literal['Text', 'Binary']` would change the type.
+    """
+    stripped = body.strip()
+    try:
+        expression = ast.parse(stripped, mode="eval")
+    except (SyntaxError, ValueError):
+        return None
+    matches = [
+        node
+        for node in ast.walk(expression)
+        if isinstance(node, ast.Name) and node.id == old_name
+    ]
+    if not matches:
+        return None
+
+    # `col_offset` counts UTF-8 bytes, so the splice has to happen in bytes.
+    source = stripped.encode()
+    line_starts = [0]
+    for line in source.split(b"\n"):
+        line_starts.append(line_starts[-1] + len(line) + 1)
+    for node in sorted(matches, key=lambda n: (n.lineno, n.col_offset), reverse=True):
+        line = line_starts[node.lineno - 1]
+        source = (
+            source[: line + node.col_offset]
+            + new_name.encode()
+            + source[line + cast(int, node.end_col_offset) :]
+        )
+
+    leading = len(body) - len(body.lstrip())
+    return body[:leading] + source.decode() + body[leading + len(stripped) :]
+
+
 def _make_builtin_alias_editor(
-    old_name: str, new_name: str, annotations_only: bool
+    old_name: str, new_name: str, type_positions_only: bool
 ) -> "TreeVisitor[Any, ExecutionContext]":
     """Create a visitor that renames a typing alias to its built-in equivalent.
 
@@ -144,8 +198,8 @@ def _make_builtin_alias_editor(
     - ``import typing [as alias]`` plus qualified ``typing.<old_name>``
       attribute references
 
-    ``annotations_only`` confines the rename to annotation context
-    (see `_in_annotation`).
+    ``type_positions_only`` confines the rename to type positions
+    (see `_in_type_position`).
 
     Import removal is delegated to the SDK's `RemoveImport`, which only
     removes imports that are no longer referenced and preserves comments.
@@ -190,7 +244,7 @@ def _make_builtin_alias_editor(
                 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))
+                and (not type_positions_only or _in_type_position(self.cursor))
             ):
                 self._rewrote_qualified = True
                 return field_access.name.replace(_simple_name=new_name).replace(
@@ -200,7 +254,7 @@ def _make_builtin_alias_editor(
 
         def visit_identifier(self, ident: Identifier, p: ExecutionContext) -> J:
             ident = cast(Identifier, super().visit_identifier(ident, p))
-            if self._bare_ref is None or ident.simple_name != self._bare_ref:
+            if self._bare_ref is None or self._bare_ref not in referenced_names(ident):
                 return ident
 
             # Skip identifiers that are part of import statements
@@ -221,9 +275,12 @@ def _make_builtin_alias_editor(
             # 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):
+            if type_positions_only and not _in_type_position(self.cursor):
                 return ident
 
+            if ident.markers.find_first(Quoted) is not None:
+                renamed = _rename_in_quoted_body(ident.simple_name, self._bare_ref, new_name)
+                return ident if renamed is None else ident.replace(_simple_name=renamed)
             return ident.replace(_simple_name=new_name)
 
     return BuiltinAliasVisitor()
@@ -235,7 +292,7 @@ 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
+    type_positions_only: ClassVar[bool] = True
 
     @property
     def name(self) -> str:
@@ -252,17 +309,18 @@ 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 in annotations. "
+            f"Replace it with the built-in `{self.new_name}` wherever a type is expected, "
+            f"including class base lists, where either spelling subclasses `{self.new_name}`. "
             "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. "
-            f"References outside an annotation are left alone: `typing.{self.old_name}` "
+            f"References in a value position 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, self.annotations_only)
+        return _make_builtin_alias_editor(self.old_name, self.new_name, self.type_positions_only)
 
 
 @categorize(_Python39)
@@ -392,7 +450,7 @@ class ReplaceTypingText(_ReplaceTypingAliasRecipe):
 
     old_name = "Text"
     new_name = "str"
-    annotations_only = False
+    type_positions_only = False
 
     @property
     def name(self) -> str:

{openrewrite_migrate_python-0.14.0.dev20260909084854 → openrewrite_migrate_python-0.14.0.dev20260909112655}/src/openrewrite_migrate_python.egg-info/PKG-INFO

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

@@ -1,5 +1,8 @@
 """Tests for typing deprecation migration recipes."""
 
+import sys
+
+import pytest
 from rewrite.test import RecipeSpec, python
 from openrewrite_migrate_python.migrate.typing_deprecations import (
     ReplaceTypingDictWithDict,
@@ -410,26 +413,6 @@ class TestPep585CornerCases:
             )
         )
 
-    def test_keeps_import_used_by_string_annotation(self):
-        """The import stays while a string annotation still references it."""
-        spec = RecipeSpec(recipe=ReplaceTypingListWithList())
-        spec.rewrite_run(
-            python(
-                """
-                from typing import List
-                x: List[int] = []
-                def f() -> "List[int]":
-                    return x
-                """,
-                """
-                from typing import List
-                x: list[int] = []
-                def f() -> "List[int]":
-                    return x
-                """,
-            )
-        )
-
     def test_removes_import_when_only_a_docstring_mentions_the_name(self):
         """Prose that happens to spell the name is not a reference to it."""
         spec = RecipeSpec(recipe=ReplaceTypingListWithList())
@@ -457,35 +440,59 @@ class TestPep585CornerCases:
             )
         )
 
-    def test_keeps_import_used_by_quoted_annotation(self):
-        """A quoted annotation the rename leaves alone still needs the import."""
+    def test_renames_inside_quoted_annotations(self):
+        """A quoted annotation holds an expression; every lookup of the alias in it is renamed."""
         spec = RecipeSpec(recipe=ReplaceTypingListWithList())
         spec.rewrite_run(
             python(
                 """
-                from typing import List
-                x: List[int] = []
-                y: "List[int]" = []
+                from typing import Dict, List
+                a: "List" = []
+                b: "List[int]" = []
+                c: "Dict[str, List[int]]" = {}
+                d: "  List[int]  " = []
+                e: "dict[Café, List[int]]" = {}
                 """,
                 """
-                from typing import List
-                x: list[int] = []
-                y: "List[int]" = []
+                from typing import Dict
+                a: "list" = []
+                b: "list[int]" = []
+                c: "Dict[str, list[int]]" = {}
+                d: "  list[int]  " = []
+                e: "dict[Café, list[int]]" = {}
                 """,
             )
         )
 
-    def test_removes_import_when_the_quoted_annotation_is_renamed(self):
-        """The rename reaches inside a bare quoted annotation, freeing the import."""
+    def test_leaves_quoted_names_that_are_not_a_lookup_alone(self):
+        """In a quoted body only an `ast.Name` is a lookup of the alias."""
         spec = RecipeSpec(recipe=ReplaceTypingListWithList())
         spec.rewrite_run(
             python(
                 """
-                from typing import List
-                x: "List" = []
+                from typing import List, Literal
+
+                alias = List
+                a: "MyList" = []
+                b: "ListLike[int]" = []
+                c: "mod.List[int]" = []
+                d: "Literal['List', 'Tuple']" = "List"
+                """
+            )
+        )
+
+    def test_leaves_quoted_annotated_metadata_alone(self):
+        """The parser quotes `Annotated` metadata like a type; only its first argument is one."""
+        spec = RecipeSpec(recipe=ReplaceTypingListWithList())
+        spec.rewrite_run(
+            python(
+                """
+                from typing import Annotated, List
+                x: Annotated["List[int]", "List"] = []
                 """,
                 """
-                x: "list" = []
+                from typing import Annotated, List
+                x: Annotated["list[int]", "List"] = []
                 """,
             )
         )
@@ -583,6 +590,118 @@ class TestPep585CornerCases:
             )
         )
 
+    def test_rewrites_pep695_type_parameter_bounds(self):
+        """A PEP 695 bound stands where a type does, on a function and on a class."""
+        spec = RecipeSpec(recipe=ReplaceTypingListWithList())
+        spec.rewrite_run(
+            python(
+                """
+                from typing import List
+
+
+                def f[U: List](x: U) -> U: ...
+
+
+                class C[U: List]: pass
+                """,
+                """
+                def f[U: list](x: U) -> U: ...
+
+
+                class C[U: list]: pass
+                """,
+            )
+        )
+
+    @pytest.mark.skipif(
+        sys.version_info < (3, 13), reason="PEP 696 type parameter defaults are 3.13+ syntax"
+    )
+    def test_rewrites_a_pep696_type_parameter_default(self):
+        """A default is a second `bounds` entry, behind an `Empty` placeholder bound."""
+        spec = RecipeSpec(recipe=ReplaceTypingListWithList())
+        spec.rewrite_run(
+            python(
+                """
+                from typing import List
+
+
+                def h[W = List](x: W) -> W: ...
+                """,
+                """
+                def h[W = list](x: W) -> W: ...
+                """,
+            )
+        )
+
+    def test_leaves_a_type_parameter_name_alone(self):
+        """`def f[List: int]` declares a type parameter; the name is not the import."""
+        spec = RecipeSpec(recipe=ReplaceTypingListWithList())
+        spec.rewrite_run(
+            python(
+                """
+                from typing import List
+
+                x: List[int] = []
+
+
+                def f[List: int](y: int) -> int: ...
+                """,
+                """
+                x: list[int] = []
+
+
+                def f[List: int](y: int) -> int: ...
+                """,
+            )
+        )
+
+    def test_rewrites_class_bases(self):
+        """A base list is a type position: either spelling subclasses `list`."""
+        spec = RecipeSpec(recipe=ReplaceTypingListWithList())
+        spec.rewrite_run(
+            python(
+                """
+                from typing import List
+
+
+                class C(List[int]): pass
+
+
+                class D(List): pass
+                """,
+                """
+                class C(list[int]): pass
+
+
+                class D(list): pass
+                """,
+            )
+        )
+
+    def test_leaves_a_class_keyword_argument_alone(self):
+        """`metaclass=List` passes the alias as a value, not as a base."""
+        spec = RecipeSpec(recipe=ReplaceTypingListWithList())
+        spec.rewrite_run(
+            python(
+                """
+                from typing import List
+
+                x: List[int] = []
+
+
+                class C(object, metaclass=List): pass
+                """,
+                """
+                from typing import List
+
+                x: list[int] = []
+
+
+                class C(object, metaclass=List): pass
+                """,
+            )
+        )
+
     def test_preserves_comment_on_removed_import(self):
         spec = RecipeSpec(recipe=ReplaceTypingListWithList())
         spec.rewrite_run(