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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrewrite-migrate-python
-Version: 0.9.0.dev20260604175301
+Version: 0.9.0.dev20260606102208
 Summary: OpenRewrite recipes for migrating Python codebases to newer Python versions.
 Author-email: "Moderne Inc." <support@moderne.io>
 License: Moderne Proprietary
@@ -21,7 +21,8 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Provides-Extra: dev
-Requires-Dist: openrewrite>=8.74.3; extra == "dev"
+Requires-Dist: openrewrite>=8.84.3; 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"
 Requires-Dist: black>=24.0.0; extra == "dev"

{openrewrite_migrate_python-0.9.0.dev20260604175301 → openrewrite_migrate_python-0.9.0.dev20260606102208}/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.dev20260604175301"  # Updated dynamically during release
+version = "0.9.0.dev20260606102208"  # Updated dynamically during release
 authors = [{ name = "Moderne Inc.", email = "support@moderne.io" }]
 license = { text = "Moderne Proprietary" }
 readme = "README.md"
@@ -30,7 +30,14 @@ dependencies = []
 
 [project.optional-dependencies]
 dev = [
-    "openrewrite>=8.74.3",
+    # 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",
+    # Needed so type-attribution tests can resolve `pydantic` types.
+    "pydantic>=2.11",
     "pytest>=8.0.0",
     "pytest-cov>=4.0.0",
     "black>=24.0.0",

{openrewrite_migrate_python-0.9.0.dev20260604175301 → openrewrite_migrate_python-0.9.0.dev20260606102208}/src/openrewrite_migrate_python/migrate/__init__.py

@@ -63,6 +63,12 @@ from .pep594_system_migrations import (
 )
 from .pipes_migrations import FindPipesModule
 from .pkgutil_deprecations import ReplacePkgutilFindLoader, ReplacePkgutilGetLoader
+from .pydantic_deprecations import (
+    FindDeprecatedJsonEncoders,
+    FindDeprecatedSchemaGenerator,
+    ReplaceFinalFieldWithClassVar,
+)
+from .pydantic_model_fields import ReplaceModelFieldsInstanceAccess
 from .re_deprecations import ReplaceReTemplate
 from .removed_modules_312 import FindRemovedModules312
 from .shutil_deprecations import FindShutilRmtreeOnerror
@@ -105,6 +111,7 @@ from .upgrade_to_python311 import UpgradeToPython311
 from .upgrade_to_python312 import UpgradeToPython312
 from .upgrade_to_python313 import UpgradeToPython313
 from .upgrade_to_python314 import UpgradeToPython314
+from .upgrade_to_pydantic import UpgradeToPydantic210, UpgradeToPydantic211
 from .urllib_deprecations import FindUrllibParseSplitFunctions, FindUrllibParseToBytes
 from .uu_migrations import FindUuModule
 from .xdrlib_migrations import FindXdrlibModule
@@ -230,4 +237,13 @@ __all__ = [
     "UpgradeToPython312",
     "UpgradeToPython313",
     "UpgradeToPython314",
+    # Auto-fix: Pydantic
+    "ReplaceModelFieldsInstanceAccess",
+    "ReplaceFinalFieldWithClassVar",
+    # Detection: Pydantic
+    "FindDeprecatedSchemaGenerator",
+    "FindDeprecatedJsonEncoders",
+    # Composite upgrade recipes: Pydantic
+    "UpgradeToPydantic210",
+    "UpgradeToPydantic211",
 ]

openrewrite_migrate_python-0.9.0.dev20260606102208/src/openrewrite_migrate_python/migrate/_markers.py

@@ -0,0 +1,22 @@
+"""Shared marker utilities for deprecation recipes."""
+
+from typing import Any, Optional
+
+from rewrite.markers import Markers, MarkupWarn
+from rewrite.utils import random_id
+
+
+def mark_deprecated(tree: Any, message: str, detail: Optional[str] = None) -> Any:
+    """Attach a ``MarkupWarn`` warning marker flagging a deprecation.
+
+    ``MarkupWarn`` is OpenRewrite's warning-markup marker (the intended marker
+    for deprecations that need manual attention), as opposed to ``SearchResult``
+    which denotes a plain search hit. It renders the same comment in printed
+    output but surfaces as a warning diagnostic in the tooling.
+    """
+    full_message = f"{message}: {detail}" if detail else message
+    warn_marker = MarkupWarn(random_id(), full_message)
+    current_markers = tree.markers
+    new_markers_list = list(current_markers.markers) + [warn_marker]
+    new_markers = Markers(current_markers.id, new_markers_list)
+    return tree.replace(_markers=new_markers)

{openrewrite_migrate_python-0.9.0.dev20260604175301 → openrewrite_migrate_python-0.9.0.dev20260606102208}/src/openrewrite_migrate_python/migrate/array_deprecations.py

@@ -18,6 +18,8 @@ from rewrite.python.preconditions import uses_method
 from rewrite.python.visitor import PythonVisitor
 from rewrite.java.tree import Identifier, MethodInvocation
 
+from rewrite.python.type_utils import is_assignable_to
+
 # Define category path: Python > Migrate > Python 3.14
 _Python314 = [
     *Python,
@@ -72,6 +74,8 @@ class ReplaceArrayTostring(Recipe):
                     return method
                 if method.name.simple_name != "tostring":
                     return method
+                if method.select is None or not is_assignable_to("array.array", method.select.type):
+                    return method
 
                 # Replace tostring with tobytes
                 new_name = method.name.replace(_simple_name="tobytes")
@@ -126,6 +130,8 @@ class ReplaceArrayFromstring(Recipe):
                     return method
                 if method.name.simple_name != "fromstring":
                     return method
+                if method.select is None or not is_assignable_to("array.array", method.select.type):
+                    return method
 
                 # Replace fromstring with frombytes
                 new_name = method.name.replace(_simple_name="frombytes")

{openrewrite_migrate_python-0.9.0.dev20260604175301 → openrewrite_migrate_python-0.9.0.dev20260606102208}/src/openrewrite_migrate_python/migrate/ast_deprecations.py

@@ -23,6 +23,8 @@ from rewrite.marketplace import Python
 from rewrite.python.visitor import PythonVisitor
 from rewrite.java.tree import Identifier, FieldAccess
 
+from rewrite.python.type_utils import is_of_class_type
+
 # Define category path: Python > Migrate > Python 3.8
 _Python38 = [
     *Python,
@@ -44,12 +46,9 @@ def _is_ast_attribute(field_access: FieldAccess, attr_name: str) -> bool:
     if field_access.name.simple_name != attr_name:
         return False
 
-    # Check if the target is 'ast'
-    target = field_access.target
-    if isinstance(target, Identifier) and target.simple_name == "ast":
-        return True
-
-    return False
+    # Confirm the target resolves to the `ast` module (by type, so aliased
+    # imports work and a same-named variable is not rewritten).
+    return is_of_class_type(field_access.target.type, "ast")
 
 
 def _replace_ast_attribute(field_access: FieldAccess, new_name: str) -> FieldAccess:

{openrewrite_migrate_python-0.9.0.dev20260604175301 → openrewrite_migrate_python-0.9.0.dev20260606102208}/src/openrewrite_migrate_python/migrate/calendar_deprecations.py

@@ -20,6 +20,8 @@ from rewrite.marketplace import Python
 from rewrite.python.visitor import PythonVisitor
 from rewrite.java.tree import Identifier, FieldAccess
 
+from rewrite.python.type_utils import is_of_class_type
+
 # Define category path: Python > Migrate > Python 3.12
 _Python312 = [
     *Python,
@@ -53,16 +55,6 @@ CALENDAR_CONSTANTS: Dict[str, str] = {
 }
 
 
-def _is_calendar_access(identifier: Identifier) -> bool:
-    """
-    Check if this identifier looks like a calendar module constant access.
-
-    Without full type attribution, we check for common patterns.
-    """
-    # The identifier itself should be a known calendar constant name
-    return identifier.simple_name in CALENDAR_CONSTANTS
-
-
 @categorize(_Python312)
 class ReplaceCalendarConstants(Recipe):
     """
@@ -118,9 +110,10 @@ class ReplaceCalendarConstants(Recipe):
                 if const_name not in CALENDAR_CONSTANTS:
                     return field_access
 
-                # Check if the target is the calendar module
+                # Confirm the target resolves to the `calendar` module (by type,
+                # so aliases work and same-named variables are excluded).
                 target = field_access.target
-                if isinstance(target, Identifier) and target.simple_name == "calendar":
+                if is_of_class_type(target.type, "calendar"):
                     # Replace with uppercase version
                     new_name_str = CALENDAR_CONSTANTS[const_name]
                     new_identifier = name.replace(_simple_name=new_name_str)

{openrewrite_migrate_python-0.9.0.dev20260604175301 → openrewrite_migrate_python-0.9.0.dev20260606102208}/src/openrewrite_migrate_python/migrate/platform_deprecations.py

@@ -16,6 +16,8 @@ from rewrite.marketplace import Python
 from rewrite.markers import Markers
 from rewrite.python.preconditions import uses_method
 from rewrite.python.visitor import PythonVisitor
+
+from rewrite.python.type_utils import is_of_class_type
 from rewrite.java.support_types import JLeftPadded, JRightPadded, Space
 from rewrite.java.tree import Identifier, Literal, MethodInvocation
 from rewrite.python.tree import NamedArgument
@@ -81,7 +83,10 @@ class ReplacePlatformPopen(Recipe):
                 select = method.select
                 if not isinstance(select, Identifier):
                     return method
-                if select.simple_name != "platform":
+                # Confirm the receiver resolves to the `platform` module (by
+                # type, so an aliased import works and a same-named variable is
+                # not rewritten into a destructive `subprocess.check_output`).
+                if not is_of_class_type(select.type, "platform"):
                     return method
 
                 # Replace platform with subprocess

openrewrite_migrate_python-0.9.0.dev20260606102208/src/openrewrite_migrate_python/migrate/pydantic_deprecations.py

@@ -0,0 +1,360 @@
+"""
+Recipes for Pydantic deprecations introduced in recent minor releases.
+
+Currently implemented:
+
+- ``ReplaceFinalFieldWithClassVar`` (Pydantic 2.11): rewrites model fields
+  annotated as ``Final`` with a default value to use ``ClassVar`` instead.
+  Before 2.11 such a field was silently treated as a class variable; the typing
+  spec says it should be a real field, so 2.11 deprecates the pattern and tells
+  users to make the intent explicit with ``ClassVar``. Rewriting to ``ClassVar``
+  preserves the current (pre-2.11) class-variable behavior.
+
+- ``FindDeprecatedSchemaGenerator`` (Pydantic 2.10): flags the deprecated
+  ``schema_generator`` option in ``ConfigDict(...)``. There is no public
+  replacement yet, so it is flagged for review rather than rewritten.
+
+- ``FindDeprecatedJsonEncoders``: flags the deprecated ``json_encoders`` option
+  in ``ConfigDict(...)``. Its replacements (serializer decorators or
+  ``PlainSerializer``) require restructuring, so it is flagged for review.
+
+See: https://docs.pydantic.dev/latest/changelog/ and
+https://github.com/pydantic/pydantic/issues/11119
+"""
+
+from typing import Any, List, Optional, cast
+
+from rewrite import ExecutionContext, Recipe, TreeVisitor
+from rewrite.category import CategoryDescriptor
+from rewrite.decorators import categorize
+from rewrite.marketplace import Python
+from rewrite.python.visitor import PythonVisitor
+from rewrite.python.add_import import AddImportOptions, maybe_add_import
+from rewrite.python.remove_import import RemoveImportOptions, maybe_remove_import
+from rewrite.python.type_utils import is_assignable_to
+from rewrite.python.tree import NamedArgument, TypeHint, TypeHintedExpression
+from rewrite.java.support_types import JavaType
+from rewrite.java.tree import (
+    Assignment,
+    ClassDeclaration,
+    FieldAccess,
+    Identifier,
+    J,
+    MethodInvocation,
+    ParameterizedType,
+)
+
+from ._markers import mark_deprecated
+
+# Define category path: Python > Migrate > Pydantic
+_Pydantic = [
+    *Python,
+    CategoryDescriptor(display_name="Migrate"),
+    CategoryDescriptor(display_name="Pydantic"),
+]
+
+# Direct base-class names that mark a class as a Pydantic model — the structural
+# check used when type attribution is unavailable.
+_PYDANTIC_BASES = frozenset({"BaseModel", "RootModel", "BaseSettings"})
+
+_SCHEMA_GEN_MSG = (
+    "Pydantic 2.10 deprecated the `schema_generator` config option; it was "
+    "experimental and is being reworked, and there is no public replacement yet."
+)
+
+_JSON_ENCODERS_MSG = (
+    "Pydantic deprecated the `json_encoders` config option; use a "
+    "`@field_serializer` / `@model_serializer`, or `Annotated[..., "
+    "PlainSerializer(...)]`, instead."
+)
+
+
+def _type_simple_name(expr: Any) -> Optional[str]:
+    """Return the trailing simple name of an Identifier or FieldAccess."""
+    if isinstance(expr, Identifier):
+        return expr.simple_name
+    if isinstance(expr, FieldAccess):
+        return expr.name.simple_name
+    return None
+
+
+def _is_pydantic_model(cls: ClassDeclaration) -> bool:
+    """True if the class is a Pydantic model.
+
+    First a structural check (direct base named ``BaseModel`` / ``RootModel`` /
+    ``BaseSettings``) that needs no type attribution. When type attribution is
+    available, an assignability check follows the resolved supertype chain, so a
+    subclass of a custom intermediate base (e.g. ``class User(MyBase)`` where
+    ``MyBase(BaseModel)``) is detected. Every Pydantic model ultimately derives
+    from ``pydantic.main.BaseModel`` (``RootModel`` and ``BaseSettings``
+    included), so a single assignability check suffices.
+    """
+    if any(_type_simple_name(base) in _PYDANTIC_BASES for base in (cls.implements or [])):
+        return True
+    # ClassDeclaration.type is a JavaType.FullyQualified, which the SDK does not
+    # model as a JavaType subtype; is_assignable_to accepts it at runtime, so
+    # cast to satisfy the type checker (drop once the SDK widens the parameter).
+    return is_assignable_to("pydantic.main.BaseModel", cast(Optional[JavaType], cls.type))
+
+
+def _flag_configdict_option(
+    visitor: PythonVisitor, arg: NamedArgument, option_name: str, message: str
+) -> Any:
+    """Flag ``arg`` if it is the named option inside a ``ConfigDict(...)`` call.
+
+    Returns a marked copy when ``arg`` is the keyword argument ``option_name``
+    whose enclosing call is ``ConfigDict``; otherwise returns ``arg`` unchanged.
+    """
+    if arg.name.simple_name != option_name:
+        return arg
+    call = visitor.cursor.first_enclosing(MethodInvocation)
+    if call is None or call.name.simple_name != "ConfigDict":
+        return arg
+    return mark_deprecated(arg, message)
+
+
+def _final_ref(type_hint: Optional[TypeHint]) -> Optional[Any]:
+    """Return the node referencing ``Final`` in the hint, or ``None``.
+
+    Unwraps ``Final[...]`` to its ``Final`` element and handles both the bare
+    name (``Final``, an ``Identifier``) and the qualified form (``typing.Final``,
+    a ``FieldAccess``).
+    """
+    if type_hint is None:
+        return None
+    tree = type_hint.type_tree
+    if isinstance(tree, ParameterizedType):
+        tree = tree.clazz
+    if isinstance(tree, Identifier) and tree.simple_name == "Final":
+        return tree
+    if isinstance(tree, FieldAccess) and tree.name.simple_name == "Final":
+        return tree
+    return None
+
+
+def _rename_final_to_classvar(ref: Any) -> Any:
+    """Rename a ``Final`` reference node to ``ClassVar``."""
+    if isinstance(ref, Identifier):
+        return ref.replace(_simple_name="ClassVar")
+    # FieldAccess (e.g. ``typing.Final``): rename only the trailing name.
+    return ref.replace(_name=ref.name.replace(_simple_name="ClassVar"))
+
+
+@categorize(_Pydantic)
+class ReplaceFinalFieldWithClassVar(Recipe):
+    """
+    Replace ``Final`` model fields that have a default value with ``ClassVar``.
+
+    Before Pydantic 2.11, a field annotated as ``Final`` with a default value was
+    silently treated as a class variable. The typing specification says it should
+    be a real field, so 2.11 deprecates the pattern and recommends making the
+    intent explicit with ``ClassVar``. Rewriting ``Final[X] = default`` to
+    ``ClassVar[X] = default`` preserves the current (pre-2.11) class-variable
+    behavior and is what Pydantic recommends.
+
+    The ``Final`` import is replaced with ``ClassVar``; if ``Final`` is still used
+    elsewhere in the file it is kept.
+
+    Example:
+        Before:
+            from typing import Final
+            from pydantic import BaseModel
+
+            class User(BaseModel):
+                name: Final[str] = "default"
+
+        After:
+            from typing import ClassVar
+            from pydantic import BaseModel
+
+            class User(BaseModel):
+                name: ClassVar[str] = "default"
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.pydantic.ReplaceFinalFieldWithClassVar"
+
+    @property
+    def display_name(self) -> str:
+        return "Replace `Final` model fields with a default with `ClassVar`"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Pydantic 2.11 deprecates annotating a model field as `Final` with a "
+            "default value (such fields were treated as class variables). Replace "
+            "`Final[X] = default` with `ClassVar[X] = default`, which preserves the "
+            "existing class-variable behavior and is the replacement Pydantic "
+            "recommends."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "migration", "pydantic", "2.11"]
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(PythonVisitor[ExecutionContext]):
+            def visit_assignment(  # type: ignore[override]
+                self, assignment: Assignment, p: ExecutionContext
+            ) -> Optional[J]:
+                a = cast(Assignment, super().visit_assignment(assignment, p))
+
+                var = a.variable
+                if not isinstance(var, TypeHintedExpression):
+                    return a
+                type_hint = var.type_hint
+                ref = _final_ref(type_hint)
+                if ref is None:
+                    return a
+
+                cls = self.cursor.first_enclosing(ClassDeclaration)
+                if cls is None or not _is_pydantic_model(cls):
+                    return a
+
+                # Rewrite the annotation: Final -> ClassVar (keeping any [X]).
+                tree = type_hint.type_tree
+                if isinstance(tree, ParameterizedType):
+                    new_tree = tree.replace(_clazz=_rename_final_to_classvar(tree.clazz))
+                else:
+                    new_tree = _rename_final_to_classvar(tree)
+                new_var = var.replace(_type_hint=type_hint.replace(_type_tree=new_tree))
+
+                # Only the bare-name form (`from typing import Final`) needs import
+                # bookkeeping; the qualified `typing.Final` form does not.
+                if isinstance(ref, Identifier):
+                    maybe_add_import(
+                        self,
+                        AddImportOptions(
+                            module="typing", name="ClassVar", only_if_referenced=False
+                        ),
+                    )
+                    maybe_remove_import(
+                        self,
+                        RemoveImportOptions(
+                            module="typing", name="Final", only_if_unused=True
+                        ),
+                    )
+
+                return a.replace(_variable=new_var)
+
+        return Visitor()
+
+
+@categorize(_Pydantic)
+class FindDeprecatedSchemaGenerator(Recipe):
+    """
+    Flag the ``schema_generator`` option in a ``ConfigDict(...)`` call.
+
+    Pydantic 2.10 deprecated the ``schema_generator`` config option (it was an
+    experimental API that is being reworked). There is no public replacement
+    yet, so this recipe flags its use for review rather than rewriting it.
+
+    Example:
+        Before:
+            from pydantic import BaseModel, ConfigDict
+
+            class User(BaseModel):
+                model_config = ConfigDict(schema_generator=MyGen)
+
+        After (option marked for review):
+            from pydantic import BaseModel, ConfigDict
+
+            class User(BaseModel):
+                model_config = ConfigDict(schema_generator=MyGen)  # flagged
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.pydantic.FindDeprecatedSchemaGenerator"
+
+    @property
+    def display_name(self) -> str:
+        return "Find deprecated `schema_generator` config option"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Pydantic 2.10 deprecated the `schema_generator` option in "
+            "`ConfigDict`. It has no public replacement yet, so this recipe "
+            "flags its use for review."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "migration", "pydantic", "2.10"]
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(PythonVisitor[ExecutionContext]):
+            def visit_named_argument(  # type: ignore[override]
+                self, named_argument: NamedArgument, p: ExecutionContext
+            ) -> Optional[J]:
+                arg = cast(
+                    NamedArgument, super().visit_named_argument(named_argument, p)
+                )
+                return _flag_configdict_option(
+                    self, arg, "schema_generator", _SCHEMA_GEN_MSG
+                )
+
+        return Visitor()
+
+
+@categorize(_Pydantic)
+class FindDeprecatedJsonEncoders(Recipe):
+    """
+    Flag the ``json_encoders`` option in a ``ConfigDict(...)`` call.
+
+    Pydantic deprecated the ``json_encoders`` config option (it carries
+    performance and implementation overhead). The recommended replacements are
+    the ``@field_serializer`` / ``@model_serializer`` decorators or an
+    ``Annotated[..., PlainSerializer(...)]`` type, which are restructurings
+    rather than a mechanical swap, so this recipe flags its use for review.
+
+    Example:
+        Before:
+            from pydantic import BaseModel, ConfigDict
+
+            class User(BaseModel):
+                model_config = ConfigDict(json_encoders={int: str})
+
+        After (option marked for review):
+            from pydantic import BaseModel, ConfigDict
+
+            class User(BaseModel):
+                model_config = ConfigDict(json_encoders={int: str})  # flagged
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.pydantic.FindDeprecatedJsonEncoders"
+
+    @property
+    def display_name(self) -> str:
+        return "Find deprecated `json_encoders` config option"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Pydantic deprecated the `json_encoders` option in `ConfigDict`. Its "
+            "replacements (`@field_serializer` / `@model_serializer` or "
+            "`Annotated[..., PlainSerializer(...)]`) require restructuring, so "
+            "this recipe flags its use for review."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "migration", "pydantic"]
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(PythonVisitor[ExecutionContext]):
+            def visit_named_argument(  # type: ignore[override]
+                self, named_argument: NamedArgument, p: ExecutionContext
+            ) -> Optional[J]:
+                arg = cast(
+                    NamedArgument, super().visit_named_argument(named_argument, p)
+                )
+                return _flag_configdict_option(
+                    self, arg, "json_encoders", _JSON_ENCODERS_MSG
+                )
+
+        return Visitor()