openrewrite-migrate-python 0.17.0.dev20261022150922__tar.gz → 0.17.0.dev20261022193254__tar.gz

{openrewrite_migrate_python-0.17.0.dev20261022150922 → openrewrite_migrate_python-0.17.0.dev20261022193254}/PKG-INFO

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

{openrewrite_migrate_python-0.17.0.dev20261022150922 → openrewrite_migrate_python-0.17.0.dev20261022193254}/src/openrewrite_migrate_python/migrate/__init__.py

@@ -44,15 +44,18 @@ from .configparser_deprecations import (
     ReplaceConfigparserReadfp,
     ReplaceConfigparserSafeConfigParser,
 )
+from .ctypes_deprecations import FindCtypesSetPointerType
 from .datetime_utc import ReplaceDatetimeUtcFromTimestamp, ReplaceDatetimeUtcNow
 from .distutils_deprecations import FindDistutilsUsage
 from .distutils_migrations import ReplaceDistutilsVersion
 from .functools_deprecations import FindFunctoolsCmpToKey
 from .future_imports import RemoveFutureImports
 from .gettext_deprecations import ReplaceGettextDeprecations
-from .glob_deprecations import ReplaceGlobGlob1
+from .glob_deprecations import FindGlobGlob0, ReplaceGlobGlob1
 from .html_parser_deprecations import ReplaceHtmlParserUnescape
+from .http_server_deprecations import FindCgiHttpRequestHandler
 from .imp_migrations import FindImpUsage
+from .importlib_deprecations import FindLoaderLoadModule
 from .importlib_resources_deprecations import ReplaceImportlibResourcesFilesPackage
 from .inspect_deprecations import FindInspectGetargspec
 from .locale_deprecations import ReplaceLocaleResetlocale
@@ -62,8 +65,8 @@ from .mailcap_migrations import FindMailcapModule
 from .module_cached_attribute import ReplaceModuleCachedAttribute
 from .nntplib_migrations import FindNntplibModule
 from .os_deprecations import FindOsPopen, FindOsSpawn
-from .pathlib_deprecations import FindPathlibLinkTo
-from .platform_deprecations import ReplacePlatformPopen
+from .pathlib_deprecations import FindPathlibIsReserved, FindPathlibLinkTo
+from .platform_deprecations import FindPlatformJavaVer, ReplacePlatformPopen
 from .pep594_system_migrations import (
     FindCryptModule,
     FindMsilibModule,
@@ -88,6 +91,7 @@ from .re_deprecations import ReplaceReTemplate
 from .removed_modules_312 import FindRemovedModules312
 from .shutil_deprecations import FindShutilRmtreeOnerror
 from .socket_deprecations import FindSocketGetFQDN
+from .sre_migrations import FindSreModules
 from .ssl_deprecations import FindSslMatchHostname
 from .string_formatting import ReplacePercentFormatWithFString, ReplaceStrFormatWithFString
 from .sys_deprecations import FindSysCheckInterval, FindSysCoroutineWrapper
@@ -95,6 +99,7 @@ from .sys_last_deprecations import ReplaceSysLastExcInfo
 from .tarfile_deprecations import ReplaceTarfileFilemode
 from .telnetlib_migrations import FindTelnetlibModule
 from .tempfile_deprecations import FindTempfileMktemp
+from .text_encoding import FindImplicitTextEncoding
 from .threading_is_alive_deprecation import ReplaceThreadIsAlive
 from .threading_deprecations import (
     ReplaceConditionNotifyAll,
@@ -106,8 +111,10 @@ from .threading_deprecations import (
     ReplaceThreadingActiveCount,
     ReplaceThreadingCurrentThread,
 )
+from .types_deprecations import FindCodeObjectCoLnotab
 from .typing_callable import ReplaceTypingCallableWithCollectionsAbcCallable
 from .typing_deprecations import (
+    FindTypingNoTypeCheckDecorator,
     ReplaceTypingDictWithDict,
     ReplaceTypingFrozenSetWithFrozenset,
     ReplaceTypingListWithList,
@@ -140,6 +147,7 @@ from .upgrade_to_pydantic import (
 )
 from .urllib_deprecations import FindUrllibParseSplitFunctions, FindUrllibParseToBytes
 from .uu_migrations import FindUuModule
+from .wave_deprecations import FindWaveMarkers
 from .xdrlib_migrations import FindXdrlibModule
 from .xml_deprecations import ReplaceElementGetchildren, ReplaceElementGetiterator
 
@@ -259,6 +267,18 @@ __all__ = [
     "ReplaceModuleCachedAttribute",
     "ReplaceNamedTupleKeywordFields",
     "ReplaceTypedDictWithoutFields",
+    # Detection: Python 3.15
+    "FindCgiHttpRequestHandler",
+    "FindCodeObjectCoLnotab",
+    "FindCtypesSetPointerType",
+    "FindGlobGlob0",
+    "FindImplicitTextEncoding",
+    "FindLoaderLoadModule",
+    "FindPathlibIsReserved",
+    "FindPlatformJavaVer",
+    "FindSreModules",
+    "FindTypingNoTypeCheckDecorator",
+    "FindWaveMarkers",
     # Auto-fix: LangChain
     "ReplaceLangchainCommunityImports",
     "ReplaceLangchainProviderImports",

openrewrite_migrate_python-0.17.0.dev20261022193254/src/openrewrite_migrate_python/migrate/_finders.py

@@ -0,0 +1,109 @@
+"""Marking calls and module-member references that a recipe only reports."""
+
+from typing import Any, Dict, List, Sequence
+
+from rewrite import Cursor, ExecutionContext, Preconditions, TreeVisitor
+from rewrite.java.tree import FieldAccess, Identifier, J, MethodInvocation
+from rewrite.python.binding_utils import import_bindings
+from rewrite.python.method_matcher import MethodMatcher
+from rewrite.python.preconditions import uses_import, uses_method
+from rewrite.python.visitor import PythonVisitor
+
+from ._markers import mark_deprecated
+
+
+def module_member_path(cursor: Cursor, node: J) -> str | None:
+    """The dotted path ``node`` reads, such as ``http.server.CGIHTTPRequestHandler``, or None.
+
+    ``cursor`` stands on ``node``. A name answers where a ``from`` import binds it, and a dotted
+    attribute where its root name is a module an import binds. A guarded or relative import binds
+    a name that may not be the standard library's, so it answers None.
+    """
+    attributes: List[str] = []
+    chain: List[FieldAccess] = []
+    root = node
+    while isinstance(root, FieldAccess):
+        attributes.append(root.name.simple_name)
+        chain.append(root)
+        root = root.target
+    if not isinstance(root, Identifier):
+        return None
+
+    root_cursor = cursor
+    for field_access in chain[1:]:
+        root_cursor = Cursor(root_cursor, field_access)
+    binding = import_bindings(cursor).reference(root_cursor, root)
+    if binding is None or binding.guarded or binding.module.startswith(".") or binding.member == "*":
+        return None
+
+    if binding.member is not None:
+        base = f"{binding.module}.{binding.member}"
+    elif binding.name == binding.module.split(".")[0]:
+        # `import http.server` binds `http`, and the code spells the rest of the path itself.
+        base = binding.name
+    else:
+        base = binding.module
+    return ".".join([base, *reversed(attributes)])
+
+
+def _gate(refs: Sequence[Any]) -> Any:
+    return refs[0] if len(refs) == 1 else Preconditions.or_(*refs)
+
+
+def find_calls(
+    patterns: Sequence[str], message: str, match_overrides: bool = False
+) -> TreeVisitor[Any, ExecutionContext]:
+    """Marks each call matching one of ``patterns``."""
+    matchers = [MethodMatcher.create(p, match_overrides=match_overrides) for p in patterns]
+
+    class Visitor(PythonVisitor[ExecutionContext]):
+        def visit_method_invocation(self, method: MethodInvocation, p: ExecutionContext) -> J:
+            m = super().visit_method_invocation(method, p)
+            if isinstance(m, MethodInvocation) and any(mm.matches(m, cursor=self.cursor) for mm in matchers):
+                return mark_deprecated(m, message)
+            return m
+
+    return Preconditions.check(
+        _gate([uses_method(p, match_overrides=match_overrides) for p in patterns]), Visitor()
+    )
+
+
+def find_member_references(messages: Dict[str, str]) -> TreeVisitor[Any, ExecutionContext]:
+    """Marks every use of a module member in ``messages``, keyed by its dotted path, called or not.
+
+    A use reaches the visitor in one of three shapes, one ``visit_*`` method each:
+
+    - a name a ``from`` import binds: ``CGIHTTPRequestHandler``, also as the name of a call
+    - a dotted attribute: ``http.server.CGIHTTPRequestHandler``
+    - a dotted call, held as a method invocation whose ``select`` is the owner rather than as a
+      field access: ``http.server.CGIHTTPRequestHandler(...)``
+
+    A name or attribute that no import binds to the module, such as ``obj.CGIHTTPRequestHandler``,
+    is left alone.
+    """
+    modules = {path.rsplit(".", 1)[0] for path in messages}
+
+    class Visitor(PythonVisitor[ExecutionContext]):
+        def visit_method_invocation(self, method: MethodInvocation, p: ExecutionContext) -> J:
+            m = super().visit_method_invocation(method, p)
+            if not isinstance(m, MethodInvocation) or m.select is None:
+                return m
+            owner = module_member_path(Cursor(self.cursor, m.select), m.select)
+            message = messages.get(f"{owner}.{m.name.simple_name}") if owner else None
+            return mark_deprecated(m, message) if message else m
+
+        def visit_field_access(self, field_access: FieldAccess, p: ExecutionContext) -> J:
+            fa = super().visit_field_access(field_access, p)
+            if not isinstance(fa, FieldAccess):
+                return fa
+            message = messages.get(module_member_path(self.cursor, fa) or "")
+            return mark_deprecated(fa, message) if message else fa
+
+        def visit_identifier(self, ident: Identifier, p: ExecutionContext) -> J:
+            i = super().visit_identifier(ident, p)
+            if not isinstance(i, Identifier):
+                return i
+            message = messages.get(module_member_path(self.cursor, i) or "")
+            return mark_deprecated(i, message) if message else i
+
+    return Preconditions.check(_gate([uses_import(m) for m in sorted(modules)]), Visitor())

openrewrite_migrate_python-0.17.0.dev20261022193254/src/openrewrite_migrate_python/migrate/ctypes_deprecations.py

@@ -0,0 +1,68 @@
+"""
+Recipe for finding the removed `ctypes.SetPointerType()`.
+
+The undocumented `ctypes.SetPointerType()` was deprecated in Python 3.13
+and removed in Python 3.15. Call `set_type()` on the incomplete pointer
+type instead.
+
+See: https://docs.python.org/3/whatsnew/3.15.html#removed
+"""
+
+from typing import Any, List
+
+from rewrite import ExecutionContext, Recipe, TreeVisitor
+from rewrite.category import CategoryDescriptor
+from rewrite.decorators import categorize
+from rewrite.marketplace import Python
+
+from ._finders import find_calls
+
+# Define category path: Python > Migrate > Python 3.15
+_Python315 = [
+    *Python,
+    CategoryDescriptor(display_name="Migrate"),
+    CategoryDescriptor(display_name="Python 3.15"),
+]
+
+
+@categorize(_Python315)
+class FindCtypesSetPointerType(Recipe):
+    """
+    Find calls to the undocumented `ctypes.SetPointerType()`, removed in
+    Python 3.15.
+
+    Example:
+        Before:
+            import ctypes
+            ctypes.SetPointerType(node_p, Node)
+
+        After:
+            import ctypes
+            node_p.set_type(Node)
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.FindCtypesSetPointerType"
+
+    @property
+    def display_name(self) -> str:
+        return "Find removed `ctypes.SetPointerType()`"
+
+    @property
+    def description(self) -> str:
+        return (
+            "The undocumented `ctypes.SetPointerType()` was removed in Python 3.15. "
+            "Call `set_type()` on the incomplete pointer type instead."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "migration", "3.15", "ctypes"]
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        return find_calls(
+            ["ctypes SetPointerType(..)"],
+            "ctypes.SetPointerType() was removed in Python 3.15. "
+            "Call set_type() on the pointer type instead.",
+        )

{openrewrite_migrate_python-0.17.0.dev20261022150922 → openrewrite_migrate_python-0.17.0.dev20261022193254}/src/openrewrite_migrate_python/migrate/glob_deprecations.py

@@ -1,8 +1,10 @@
 """
-Recipe for replacing the removed `glob.glob1()`.
+Recipes for the removed `glob.glob0()` and `glob.glob1()`.
 
-The undocumented `glob.glob1()` was deprecated in Python 3.13 and removed
-in Python 3.15. `glob.glob()` with `root_dir` returns the same names.
+The undocumented `glob.glob0()` and `glob.glob1()` were deprecated in
+Python 3.13 and removed in Python 3.15. `glob.glob()` with `root_dir`
+returns the same names as `glob1()`. `glob0()` treated its argument
+literally rather than as a pattern, so its calls are only found.
 
 See: https://docs.python.org/3/whatsnew/3.15.html#glob
 """
@@ -21,6 +23,8 @@ from rewrite.python.template import capture, template
 from rewrite.python.tree import NamedArgument
 from rewrite.python.visitor import PythonVisitor
 
+from ._finders import find_calls
+
 # Define category path: Python > Migrate > Python 3.15
 _Python315 = [
     *Python,
@@ -110,3 +114,48 @@ class ReplaceGlobGlob1(Recipe):
                 return replaced
 
         return Preconditions.check(uses_method(_GLOB1), Visitor())
+
+
+@categorize(_Python315)
+class FindGlobGlob0(Recipe):
+    """
+    Find calls to the undocumented `glob.glob0()`, removed in Python 3.15.
+
+    `glob0(dirname, basename)` returned `[basename]` when it existed in
+    `dirname`, treating `basename` literally rather than as a pattern.
+
+    Example:
+        Before:
+            import glob
+            glob.glob0("src", "setup.py")
+
+        After:
+            import os.path
+            ["setup.py"] if os.path.lexists(os.path.join("src", "setup.py")) else []
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.FindGlobGlob0"
+
+    @property
+    def display_name(self) -> str:
+        return "Find removed `glob.glob0()`"
+
+    @property
+    def description(self) -> str:
+        return (
+            "The undocumented `glob.glob0()` was removed in Python 3.15. Use `glob.glob()` with "
+            "`root_dir`, escaping the name with `glob.escape()`, or test for the file directly."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "migration", "3.15", "glob"]
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        return find_calls(
+            ["glob glob0(..)"],
+            "glob.glob0() was removed in Python 3.15. "
+            "Use glob.glob(glob.escape(basename), root_dir=dirname) instead.",
+        )

openrewrite_migrate_python-0.17.0.dev20261022193254/src/openrewrite_migrate_python/migrate/http_server_deprecations.py

@@ -0,0 +1,61 @@
+"""
+Recipe for finding the removed `http.server.CGIHTTPRequestHandler`.
+
+`CGIHTTPRequestHandler` was deprecated in Python 3.13 and removed in
+Python 3.15, along with the `--cgi` flag of `python -m http.server`.
+
+See: https://docs.python.org/3/whatsnew/3.15.html#removed
+"""
+
+from typing import Any, List
+
+from rewrite import ExecutionContext, Recipe, TreeVisitor
+from rewrite.category import CategoryDescriptor
+from rewrite.decorators import categorize
+from rewrite.marketplace import Python
+
+from ._finders import find_member_references
+
+# Define category path: Python > Migrate > Python 3.15
+_Python315 = [
+    *Python,
+    CategoryDescriptor(display_name="Migrate"),
+    CategoryDescriptor(display_name="Python 3.15"),
+]
+
+
+@categorize(_Python315)
+class FindCgiHttpRequestHandler(Recipe):
+    """
+    Find references to `http.server.CGIHTTPRequestHandler`, removed in
+    Python 3.15.
+
+    Example:
+        Before:
+            from http.server import CGIHTTPRequestHandler, HTTPServer
+            HTTPServer(("", 8000), CGIHTTPRequestHandler).serve_forever()
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.FindCgiHttpRequestHandler"
+
+    @property
+    def display_name(self) -> str:
+        return "Find removed `http.server.CGIHTTPRequestHandler`"
+
+    @property
+    def description(self) -> str:
+        return (
+            "`http.server.CGIHTTPRequestHandler` was removed in Python 3.15, along with the `--cgi` "
+            "flag of `python -m http.server`. Serve CGI scripts through a WSGI or ASGI server instead."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "migration", "3.15", "http.server"]
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        return find_member_references({
+            "http.server.CGIHTTPRequestHandler": "http.server.CGIHTTPRequestHandler was removed in Python 3.15.",
+        })

openrewrite_migrate_python-0.17.0.dev20261022193254/src/openrewrite_migrate_python/migrate/importlib_deprecations.py

@@ -0,0 +1,136 @@
+"""
+Recipe for finding the removed `load_module()` of import loaders.
+
+Python 3.15 removed `importlib.abc.Loader.load_module()` and
+`zipimport.zipimporter.load_module()`, and the import system no longer
+calls `load_module()` on a custom loader.
+
+See: https://docs.python.org/3/whatsnew/3.15.html#removed
+"""
+
+from typing import Any, List
+
+from rewrite import Cursor, ExecutionContext, Preconditions, Recipe, TreeVisitor
+from rewrite.category import CategoryDescriptor
+from rewrite.decorators import categorize
+from rewrite.marketplace import Python
+from rewrite.java.tree import ClassDeclaration, J, MethodDeclaration, MethodInvocation
+from rewrite.python.method_matcher import MethodMatcher
+from rewrite.python.preconditions import uses_method, uses_type
+from rewrite.python.type_utils import is_assignable_to
+from rewrite.python.visitor import PythonVisitor
+
+from ._markers import mark_deprecated
+
+# Define category path: Python > Migrate > Python 3.15
+_Python315 = [
+    *Python,
+    CategoryDescriptor(display_name="Migrate"),
+    CategoryDescriptor(display_name="Python 3.15"),
+]
+
+
+def _is_loader(type_: Any) -> bool:
+    return any(is_assignable_to(loader, type_) for loader in _LOADER_TYPES)
+
+
+def _declaring_class(cursor: Cursor) -> ClassDeclaration | None:
+    """The class whose body declares the method ``cursor`` stands on, None for a nested function."""
+    enclosing = cursor.parent
+    while enclosing is not None:
+        if isinstance(enclosing.value, ClassDeclaration):
+            return enclosing.value
+        if isinstance(enclosing.value, MethodDeclaration):
+            return None
+        enclosing = enclosing.parent
+    return None
+
+
+# typeshed declares `importlib.abc.Loader` in `importlib._abc` and re-exports it.
+_LOADER_TYPES = ("importlib._abc.Loader", "importlib.abc.Loader")
+_LOAD_MODULE_PATTERNS = [
+    *(f"{loader} load_module(..)" for loader in _LOADER_TYPES),
+    "zipimport.zipimporter load_module(..)",
+]
+_LOAD_MODULE_MESSAGE = (
+    "load_module() was removed in Python 3.15, and the import system no longer calls it. "
+    "Implement create_module() and exec_module() instead."
+)
+
+
+@categorize(_Python315)
+class FindLoaderLoadModule(Recipe):
+    """
+    Find `load_module()` calls on, and definitions in, import loaders.
+
+    Python 3.15 removed `importlib.abc.Loader.load_module()` and
+    `zipimport.zipimporter.load_module()`, and the import system no longer
+    calls `load_module()` on a custom loader. A loader that only defines
+    `load_module()` stops loading anything.
+
+    Example:
+        Before:
+            import importlib.abc
+
+            class Loader(importlib.abc.Loader):
+                def load_module(self, fullname): ...
+
+        After:
+            import importlib.abc
+
+            class Loader(importlib.abc.Loader):
+                def create_module(self, spec): ...
+                def exec_module(self, module): ...
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.FindLoaderLoadModule"
+
+    @property
+    def display_name(self) -> str:
+        return "Find removed `load_module()` on import loaders"
+
+    @property
+    def description(self) -> str:
+        return (
+            "`importlib.abc.Loader.load_module()` and `zipimport.zipimporter.load_module()` were "
+            "removed in Python 3.15, and the import system no longer calls `load_module()` on a "
+            "custom loader. Marks calls to it and its definitions in `Loader` subclasses. Only fires "
+            "where the receiver's or class's type resolves."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "migration", "3.15", "importlib"]
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        matchers = [MethodMatcher.create(p, match_overrides=True) for p in _LOAD_MODULE_PATTERNS]
+
+        class Visitor(PythonVisitor[ExecutionContext]):
+            def visit_method_invocation(self, method: MethodInvocation, p: ExecutionContext) -> J:
+                m = super().visit_method_invocation(method, p)
+                if not isinstance(m, MethodInvocation) or m.name.simple_name != "load_module":
+                    return m
+                # A loader subclass declares its own `load_module`, which the method type names
+                # without the class hierarchy, so the receiver's type decides it.
+                if any(mm.matches(m, cursor=self.cursor) for mm in matchers) or (
+                    m.select is not None and _is_loader(m.select.type)
+                ):
+                    return mark_deprecated(m, _LOAD_MODULE_MESSAGE)
+                return m
+
+            def visit_method_declaration(self, method: MethodDeclaration, p: ExecutionContext) -> J:
+                md = super().visit_method_declaration(method, p)
+                if not isinstance(md, MethodDeclaration) or md.name.simple_name != "load_module":
+                    return md
+                owner = _declaring_class(self.cursor)
+                if owner is not None and _is_loader(owner.type):
+                    return mark_deprecated(md, _LOAD_MODULE_MESSAGE)
+                return md
+
+        gate = Preconditions.or_(
+            *(uses_method(p, match_overrides=True) for p in _LOAD_MODULE_PATTERNS),
+            *(uses_type(loader, check_assignability=True) for loader in _LOADER_TYPES),
+        )
+        return Preconditions.check(gate, Visitor())

{openrewrite_migrate_python-0.17.0.dev20261022150922 → openrewrite_migrate_python-0.17.0.dev20261022193254}/src/openrewrite_migrate_python/migrate/pathlib_deprecations.py

@@ -4,6 +4,9 @@ Recipes for migrating deprecated pathlib methods.
 Path.link_to() was deprecated in Python 3.10 and removed in Python 3.12.
 Use Path.hardlink_to() instead (note the reversed argument order).
 
+PurePath.is_reserved() was deprecated in Python 3.13 and removed in
+Python 3.15. Use os.path.isreserved(), which is only available on Windows.
+
 See: https://docs.python.org/3/library/pathlib.html
 """
 
@@ -18,6 +21,7 @@ from rewrite.python.preconditions import uses_method
 from rewrite.python.visitor import PythonVisitor
 from rewrite.java.tree import J, MethodInvocation
 from ._markers import mark_deprecated
+from ._finders import find_calls
 
 _LINK_TO = "pathlib.Path link_to(..)"
 _LINK_TO_MATCHER = MethodMatcher.create(_LINK_TO, match_overrides=True)
@@ -29,6 +33,12 @@ _Python312 = [
     CategoryDescriptor(display_name="Python 3.12"),
 ]
 
+_Python315 = [
+    *Python,
+    CategoryDescriptor(display_name="Migrate"),
+    CategoryDescriptor(display_name="Python 3.15"),
+]
+
 
 @categorize(_Python312)
 class FindPathlibLinkTo(Recipe):
@@ -88,3 +98,52 @@ class FindPathlibLinkTo(Recipe):
                 )
 
         return Preconditions.check(uses_method(_LINK_TO, match_overrides=True), Visitor())
+
+
+@categorize(_Python315)
+class FindPathlibIsReserved(Recipe):
+    """
+    Find calls to `PurePath.is_reserved()`, removed in Python 3.15.
+
+    `os.path.isreserved()` is the replacement, but only exists on Windows,
+    where reserved names exist at all. `PurePosixPath.is_reserved()` always
+    returned `False`, so code that is not Windows-only can usually drop the
+    check.
+
+    Example:
+        Before:
+            from pathlib import PureWindowsPath
+            PureWindowsPath("nul").is_reserved()
+
+        After:
+            import os.path
+            os.path.isreserved("nul")  # on Windows
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.FindPathlibIsReserved"
+
+    @property
+    def display_name(self) -> str:
+        return "Find removed `PurePath.is_reserved()`"
+
+    @property
+    def description(self) -> str:
+        return (
+            "`pathlib.PurePath.is_reserved()` was removed in Python 3.15. Use `os.path.isreserved()`, "
+            "which is only available on Windows. Only fires where the receiver's type resolves to a "
+            "`pathlib` path."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "migration", "3.15", "pathlib"]
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        return find_calls(
+            ["pathlib.PurePath is_reserved(..)"],
+            "PurePath.is_reserved() was removed in Python 3.15. "
+            "Use os.path.isreserved(), which is only available on Windows.",
+            match_overrides=True,
+        )