openrewrite-migrate-python 0.12.0.dev20260811172040__tar.gz → 0.13.0__tar.gz

{openrewrite_migrate_python-0.12.0.dev20260811172040 → openrewrite_migrate_python-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrewrite-migrate-python
-Version: 0.12.0.dev20260811172040
+Version: 0.13.0
 Summary: OpenRewrite recipes for migrating Python codebases to newer Python versions.
 Author-email: "Moderne Inc." <support@moderne.io>
 License: Moderne Proprietary
@@ -21,7 +21,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Provides-Extra: dev
-Requires-Dist: openrewrite>=8.84.3; extra == "dev"
+Requires-Dist: openrewrite>=8.89.1; extra == "dev"
 Requires-Dist: pydantic>=2.11; extra == "dev"
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"

{openrewrite_migrate_python-0.12.0.dev20260811172040 → openrewrite_migrate_python-0.13.0}/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.12.0.dev20260811172040"  # Updated dynamically during release
+version = "0.13.0"  # Updated dynamically during release
 authors = [{ name = "Moderne Inc.", email = "support@moderne.io" }]
 license = { text = "Moderne Proprietary" }
 readme = "README.md"
@@ -30,12 +30,11 @@ dependencies = []
 
 [project.optional-dependencies]
 dev = [
-    # 8.84.3 brings ty external-type resolution (cross-package supertype chains),
-    # J.MethodInvocation.type, sorted insertion in maybe_add_import, and the
-    # type_utils comparison helpers — all of which the recipes rely on for
-    # type-aware matching. openrewrite is host-provided at runtime, so this floor
-    # only affects dev/CI.
-    "openrewrite>=8.84.3",
+    # 8.89.1 for `python.scope_utils.LocalBindings`, which tells a local apart from a
+    # reference to an import: the PEP 585 recipes use it directly, and `ChangeImport`
+    # and `RemoveImport` need it to see references inside functions. openrewrite is
+    # host-provided at runtime, so this floor only affects dev/CI.
+    "openrewrite>=8.89.1",
     # Needed so type-attribution tests can resolve `pydantic` types.
     "pydantic>=2.11",
     "pytest>=8.0.0",

openrewrite_migrate_python-0.13.0/src/openrewrite_code_quality_python/codequality/find_suspicious_chained_comparison.py

@@ -0,0 +1,122 @@
+"""
+Recipe to find suspicious chained comparisons with conflicting direction.
+
+Python evaluates ``a < b < c`` as ``(a < b) and (b < c)``. When the two
+links point in opposite directions--one of ``<``/``<=`` and the other of
+``>``/``>=``--the chain is almost always a mistake, e.g. ``0 <= x >= 10``
+was likely meant to be ``0 <= x <= 10``. This is a search recipe: the
+intent is ambiguous, so it flags the expression rather than rewriting it.
+"""
+
+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, SearchResult
+from rewrite.python.visitor import PythonVisitor
+from rewrite.java.tree import Binary as JBinary, Expression
+from rewrite.utils import random_id
+
+_CodeQuality = [
+    *Python,
+    CategoryDescriptor(display_name="Code quality"),
+]
+
+_LESS = (JBinary.Type.LessThan, JBinary.Type.LessThanOrEqual)
+_GREATER = (JBinary.Type.GreaterThan, JBinary.Type.GreaterThanOrEqual)
+
+
+def _direction(operator: JBinary.Type) -> Optional[str]:
+    """Classify an ordering operator as ``"less"``, ``"greater"``, or None."""
+    if operator in _LESS:
+        return "less"
+    if operator in _GREATER:
+        return "greater"
+    return None
+
+
+def _mark(tree: Expression) -> Expression:
+    """Attach a SearchResult flagging the conflicting chained comparison."""
+    message = (
+        "Suspicious chained comparison: the two comparisons point in "
+        "opposite directions, so the chain narrows to a surprising range. "
+        "Did you mean to keep both comparisons in the same direction?"
+    )
+    marker = SearchResult(random_id(), message)
+    current = tree.markers
+    return tree.replace(
+        _markers=Markers(current.id, list(current.markers) + [marker])
+    )
+
+
+@categorize(_CodeQuality)
+class FindSuspiciousChainedComparison(Recipe):
+    """
+    Find chained comparisons whose links point in opposite directions.
+
+    A chain such as ``0 <= x >= 10`` reads as ``0 <= x and x >= 10``, which
+    is a needlessly convoluted way to say ``x >= 10`` and is almost always a
+    typo for ``0 <= x <= 10``. Mixing ``<``/``<=`` with ``>``/``>=`` in a
+    single chain is the tell-tale sign.
+
+    Example:
+        Flagged:
+            if 0 <= x >= 10:
+                pass
+
+        Not flagged (monotonic):
+            if 0 <= x <= 10:
+                pass
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.codequality.FindSuspiciousChainedComparison"
+
+    @property
+    def display_name(self) -> str:
+        return "Find suspicious chained comparisons"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Find chained comparisons that mix `<`/`<=` with `>`/`>=` (for "
+            "example `0 <= x >= 10`), where the links point in opposite "
+            "directions and the chain is almost always a mistake."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "code-quality"]
+
+    @property
+    def estimated_effort_per_occurrence(self) -> int:
+        return 5
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(PythonVisitor[ExecutionContext]):
+            def visit_binary(
+                self, binary: JBinary, p: ExecutionContext
+            ) -> Optional[Expression]:
+                binary = super().visit_binary(binary, p)
+
+                if not isinstance(binary, JBinary):
+                    return binary
+
+                outer = _direction(binary.operator)
+                if outer is None:
+                    return binary
+
+                inner = binary.left
+                if not isinstance(inner, JBinary):
+                    return binary
+
+                left = _direction(inner.operator)
+                if left is None or left == outer:
+                    return binary
+
+                return _mark(binary)
+
+        return Visitor()

{openrewrite_migrate_python-0.12.0.dev20260811172040 → openrewrite_migrate_python-0.13.0}/src/openrewrite_migrate_python/migrate/typing_deprecations.py

@@ -29,6 +29,7 @@ from rewrite.decorators import categorize
 from rewrite.marketplace import Python
 from rewrite.python.import_utils import get_alias_name, get_name_string, get_qualid_name
 from rewrite.python.remove_import import RemoveImportOptions, maybe_remove_import
+from rewrite.python.scope_utils import LocalBindings
 
 from ._typing_imports import maybe_remove_typing_module_import
 from rewrite.python.tree import CompilationUnit, MultiImport, NamedArgument
@@ -39,8 +40,6 @@ from rewrite.java.tree import (
     Import,
     J,
     Literal,
-    MethodDeclaration,
-    VariableDeclarations,
 )
 
 # Define category paths
@@ -81,6 +80,7 @@ def _make_builtin_alias_editor(old_name: str, new_name: str) -> "TreeVisitor[Any
             self._module_refs: Set[str] = set()
             self._keep_from_import: bool = False
             self._rewrote_qualified: bool = False
+            self._local_bindings = LocalBindings()
 
         def visit_compilation_unit(
             self, cu: CompilationUnit, p: ExecutionContext
@@ -88,6 +88,7 @@ def _make_builtin_alias_editor(old_name: str, new_name: str) -> "TreeVisitor[Any
             self._bare_ref = None
             self._module_refs = set()
             self._rewrote_qualified = False
+            self._local_bindings = LocalBindings()
 
             for stmt in cu.statements:
                 if isinstance(stmt, MultiImport):
@@ -172,19 +173,8 @@ def _make_builtin_alias_editor(old_name: str, new_name: str) -> "TreeVisitor[Any
             # A keyword-argument name (`f(List=...)`) names a parameter.
             if isinstance(parent, NamedArgument) and parent.name.id == ident.id:
                 return ident
-            # A declaration target (`List = ...`, `def f(List): ...`) binds a
-            # new name rather than referencing the import.
-            if (
-                isinstance(parent, VariableDeclarations.NamedVariable)
-                and parent.name.id == ident.id
-            ):
-                return ident
-            # Inside function scopes, type attribution marks shadowed locals
-            # with a field type; module-level references never carry one.
-            if (
-                self.cursor.first_enclosing(MethodDeclaration) is not None
-                and ident.field_type is not None
-            ):
+            # 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
 
             return ident.replace(_simple_name=new_name)

{openrewrite_migrate_python-0.12.0.dev20260811172040 → openrewrite_migrate_python-0.13.0}/src/openrewrite_migrate_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrewrite-migrate-python
-Version: 0.12.0.dev20260811172040
+Version: 0.13.0
 Summary: OpenRewrite recipes for migrating Python codebases to newer Python versions.
 Author-email: "Moderne Inc." <support@moderne.io>
 License: Moderne Proprietary
@@ -21,7 +21,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Provides-Extra: dev
-Requires-Dist: openrewrite>=8.84.3; extra == "dev"
+Requires-Dist: openrewrite>=8.89.1; extra == "dev"
 Requires-Dist: pydantic>=2.11; extra == "dev"
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"

{openrewrite_migrate_python-0.12.0.dev20260811172040 → openrewrite_migrate_python-0.13.0}/src/openrewrite_migrate_python.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ src/openrewrite_code_quality_python/codequality/_semantically_equal.py
 src/openrewrite_code_quality_python/codequality/all_branches_identical.py
 src/openrewrite_code_quality_python/codequality/boolean_checks_not_inverted.py
 src/openrewrite_code_quality_python/codequality/collapsible_if_statements.py
+src/openrewrite_code_quality_python/codequality/find_suspicious_chained_comparison.py
 src/openrewrite_code_quality_python/codequality/merge_identical_branches.py
 src/openrewrite_code_quality_python/codequality/remove_duplicate_conditions.py
 src/openrewrite_code_quality_python/codequality/remove_self_assignment.py

{openrewrite_migrate_python-0.12.0.dev20260811172040 → openrewrite_migrate_python-0.13.0}/src/openrewrite_migrate_python.egg-info/requires.txt

@@ -1,6 +1,6 @@
 
 [dev]
-openrewrite>=8.84.3
+openrewrite>=8.89.1
 pydantic>=2.11
 pytest>=8.0.0
 pytest-cov>=4.0.0

{openrewrite_migrate_python-0.12.0.dev20260811172040 → openrewrite_migrate_python-0.13.0}/tests/test_typing_alias_moves.py

@@ -120,6 +120,38 @@ class TestTypingAliasMoves:
             )
         )
 
+    @pytest.mark.parametrize("alias", sorted(a for a in EXPECTED_MOVES if EXPECTED_MOVES[a][1]))
+    def test_migrates_alias_referenced_inside_a_function(self, alias):
+        module, new_name = EXPECTED_MOVES[alias]
+        spec = RecipeSpec(
+            recipe=ChangeImport(
+                old_module="typing",
+                old_name=alias,
+                new_module=module,
+                new_name=new_name,
+            )
+        )
+        spec.rewrite_run(
+            python(
+                f"""
+                from typing import {alias}
+
+
+                def f(q: {alias}) -> {alias}:
+                    local: {alias} = q
+                    return local
+                """,
+                f"""
+                from {module} import {new_name}
+
+
+                def f(q: {new_name}) -> {new_name}:
+                    local: {new_name} = q
+                    return local
+                """,
+            )
+        )
+
     def test_migrating_all_names_of_an_import_leaves_no_blank_line(self):
         spec = RecipeSpec().with_recipes(
             ChangeImport(old_module="typing", old_name="Iterable", new_module="collections.abc"),

{openrewrite_migrate_python-0.12.0.dev20260811172040 → openrewrite_migrate_python-0.13.0}/tests/test_typing_deprecations.py

@@ -317,6 +317,99 @@ class TestPep585CornerCases:
             )
         )
 
+    def test_renames_usages_inside_functions(self):
+        spec = RecipeSpec(recipe=ReplaceTypingListWithList())
+        spec.rewrite_run(
+            python(
+                """
+                from typing import List
+
+
+                def collect(items: List[str]) -> List[int]:
+                    order: List[int] = []
+                    for item in items:
+                        order.append(len(item))
+                    return order
+                """,
+                """
+                def collect(items: list[str]) -> list[int]:
+                    order: list[int] = []
+                    for item in items:
+                        order.append(len(item))
+                    return order
+                """,
+            )
+        )
+
+    def test_narrows_import_to_names_without_builtin_equivalents(self):
+        spec = RecipeSpec(recipe=ReplaceTypingListWithList())
+        spec.rewrite_run(
+            python(
+                """
+                from typing import Dict, List, Optional
+
+
+                def resolve(names: List[str], mapping: Dict[str, str]) -> Optional[str]:
+                    return mapping.get(names[0])
+                """,
+                """
+                from typing import Dict, Optional
+
+
+                def resolve(names: list[str], mapping: Dict[str, str]) -> Optional[str]:
+                    return mapping.get(names[0])
+                """,
+            )
+        )
+
+    def test_leaves_a_local_that_shadows_the_import(self):
+        spec = RecipeSpec(recipe=ReplaceTypingListWithList())
+        spec.rewrite_run(
+            python(
+                """
+                from typing import List
+
+                x: List[int] = []
+
+
+                def render():
+                    List = ", ".join(str(i) for i in x)
+                    return List
+                """,
+                """
+                x: list[int] = []
+
+
+                def render():
+                    List = ", ".join(str(i) for i in x)
+                    return List
+                """,
+            )
+        )
+
+    def test_leaves_a_parameter_that_shadows_the_import(self):
+        spec = RecipeSpec(recipe=ReplaceTypingListWithList())
+        spec.rewrite_run(
+            python(
+                """
+                from typing import List
+
+                x: List[int] = []
+
+
+                def render(List):
+                    return List
+                """,
+                """
+                x: list[int] = []
+
+
+                def render(List):
+                    return List
+                """,
+            )
+        )
+
     def test_keeps_import_used_by_string_annotation(self):
         """The import stays while a string annotation still references it."""
         spec = RecipeSpec(recipe=ReplaceTypingListWithList())

{openrewrite_migrate_python-0.12.0.dev20260811172040 → openrewrite_migrate_python-0.13.0}/tests/test_upgrade_recipes.py

@@ -9,7 +9,9 @@ from openrewrite_migrate_python.migrate import (
     UpgradeToPython313,
     UpgradeToPython314,
 )
+from rewrite import Recipe
 from rewrite.rpc import RpcRecipe
+from rewrite.test import RecipeSpec, python
 
 class TestUpgradeRecipeChaining:
     """Tests for verifying upgrade recipe chaining."""
@@ -203,3 +205,105 @@ class TestPydanticUpgradeChaining:
         recipe = UpgradeToPydantic211()
         assert recipe.name == "org.openrewrite.python.migrate.pydantic.UpgradeToPydantic211"
         assert "pydantic" in recipe.tags
+
+
+class _NativeUpgradeToPython313(Recipe):
+    """`UpgradeToPython313` without its `RpcRecipe` steps, which need a Java host."""
+
+    @property
+    def name(self) -> str:
+        return "test.NativeUpgradeToPython313"
+
+    @property
+    def display_name(self) -> str:
+        return "Upgrade to Python 3.13 (native steps only)"
+
+    @property
+    def description(self) -> str:
+        return "Runs the in-process steps of `UpgradeToPython313` in composite order."
+
+    def recipe_list(self):
+        def leaves(recipe):
+            for sub in recipe.recipe_list():
+                if isinstance(sub, RpcRecipe):
+                    continue
+                nested = sub.recipe_list()
+                if nested:
+                    yield from leaves(sub)
+                else:
+                    yield sub
+
+        return list(leaves(UpgradeToPython313()))
+
+
+class TestUpgradeToPython313TypingConsistency:
+    """The typing imports a file keeps must match the names it still uses."""
+
+    def test_migrates_imports_and_usages_together(self):
+        spec = RecipeSpec(recipe=_NativeUpgradeToPython313())
+        spec.rewrite_run(
+            python(
+                """
+                from typing import List, Dict, Set, Tuple, Optional, Callable, Iterable
+
+
+                def collect(items: List[str], index: Dict[str, int]) -> Tuple[Set[str], List[int]]:
+                    seen: Set[str] = set()
+                    order: List[int] = []
+                    for item in items:
+                        if item not in seen:
+                            seen.add(item)
+                            order.append(index.get(item, -1))
+                    return seen, order
+
+
+                def apply_all(fns: Iterable[Callable[[int], int]], value: int) -> Optional[int]:
+                    for fn in fns:
+                        value = fn(value)
+                    return value
+                """,
+                """
+                from collections.abc import Callable, Iterable
+
+
+                def collect(items: list[str], index: dict[str, int]) -> tuple[set[str], list[int]]:
+                    seen: set[str] = set()
+                    order: list[int] = []
+                    for item in items:
+                        if item not in seen:
+                            seen.add(item)
+                            order.append(index.get(item, -1))
+                    return seen, order
+
+
+                def apply_all(fns: Iterable[Callable[[int], int]], value: int) -> int | None:
+                    for fn in fns:
+                        value = fn(value)
+                    return value
+                """,
+            )
+        )
+
+    def test_migrates_imports_and_usages_together_in_a_smaller_file(self):
+        spec = RecipeSpec(recipe=_NativeUpgradeToPython313())
+        spec.rewrite_run(
+            python(
+                """
+                from typing import List, Dict, Optional
+
+
+                def resolve(names: List[str], mapping: Dict[str, str]) -> Optional[str]:
+                    for name in names:
+                        if name in mapping:
+                            return mapping[name]
+                    return None
+                """,
+                """
+                def resolve(names: list[str], mapping: dict[str, str]) -> str | None:
+                    for name in names:
+                        if name in mapping:
+                            return mapping[name]
+                    return None
+                """,
+            )
+        )