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

{openrewrite_migrate_python-0.14.0.dev20260909100643 → 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.dev20260909100643
+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.dev20260909100643 → 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.dev20260909100643"  # 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.dev20260909100643 → openrewrite_migrate_python-0.14.0.dev20260909112655}/src/openrewrite_migrate_python/migrate/typing_deprecations.py

@@ -40,6 +40,7 @@ from ._typing_imports import (
 from rewrite.python.tree import (
     CollectionLiteral,
     CompilationUnit,
+    ExpressionTypeTree,
     MultiImport,
     NamedArgument,
     TypeAlias,
@@ -50,11 +51,13 @@ from rewrite.python.visitor import PythonVisitor
 from rewrite.java.tree import (
     ArrayAccess,
     Assignment,
+    ClassDeclaration,
     FieldAccess,
     Identifier,
     Import,
     J,
     ParameterizedType,
+    TypeParameter,
     VariableDeclarations,
 )
 
@@ -105,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()
@@ -125,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)
@@ -174,7 +187,7 @@ def _rename_in_quoted_body(body: str, old_name: str, new_name: str) -> Optional[
 
 
 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.
 
@@ -185,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.
@@ -231,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(
@@ -262,7 +275,7 @@ 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:
@@ -279,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:
@@ -296,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)
@@ -436,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.dev20260909100643 → 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.dev20260909100643
+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.dev20260909100643 → 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,
@@ -587,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(