gh-142418: Fix inspect.iscoroutinefunction for marked functools.partial and partialmethod objects

Doc/using/cmdline.rst

@@ -302,16 +302,22 @@ Miscellaneous options
 
 .. option:: -i
 
-   Enter interactive mode after execution.
+   Enter interactive mode after execution, or force interactive mode even when
+   :data:`sys.stdin` does not appear to be a terminal.
 
    Using the :option:`-i` option will enter interactive mode in any of the following circumstances\:
 
    * When a script is passed as first argument
    * When the :option:`-c` option is used
    * When the :option:`-m` option is used
 
-   Interactive mode will start even when :data:`sys.stdin` does not appear to be a terminal. The
-   :envvar:`PYTHONSTARTUP` file is not read.
+   In these "execute then interact" cases, Python runs the script or command
+   first and does not read the :envvar:`PYTHONSTARTUP` file before entering
+   interactive mode.
+
+   When :option:`-i` is used only to force interactive mode despite redirected
+   standard input (for example, ``python -i < /dev/null``), the interpreter
+   enters interactive mode directly and reads :envvar:`PYTHONSTARTUP` as usual.
 
    This can be useful to inspect global variables or a stack trace when a script
    raises an exception.  See also :envvar:`PYTHONINSPECT`.

Lib/inspect.py

@@ -306,10 +306,28 @@ def isgeneratorfunction(obj):
 _is_coroutine_mark = object()
 
 def _has_coroutine_mark(f):
-    while ismethod(f):
-        f = f.__func__
-    f = functools._unwrap_partial(f)
-    return getattr(f, "_is_coroutine_marker", None) is _is_coroutine_mark
+    while True:
+        # Methods: unwrap first (methods cannot be coroutine-marked)
+        if ismethod(f):
+            f = f.__func__
+            continue
+
+        # Direct marker check
+        if getattr(f, "_is_coroutine_marker", None) is _is_coroutine_mark:
+            return True
+
+        # Functions created by partialmethod descriptors keep a __partialmethod__ reference
+        pm = getattr(f, "__partialmethod__", None)
+        if isinstance(pm, functools.partialmethod):
+            f = pm
+            continue
+
+        # partial and partialmethod share .func
+        if isinstance(f, (functools.partial, functools.partialmethod)):
+            f = f.func
+            continue
+
+        return False
 
 def markcoroutinefunction(func):
     """

Lib/test/test_inspect/test_inspect.py

@@ -380,6 +380,27 @@ def do_something_static():
 
         coro.close(); gen_coro.close(); # silence warnings
 
+    def test_marked_partials_are_coroutinefunctions(self):
+        def regular_function():
+            pass
+
+        marked_partial = inspect.markcoroutinefunction(
+            functools.partial(regular_function))
+        self.assertTrue(inspect.iscoroutinefunction(marked_partial))
+        self.assertFalse(
+            inspect.iscoroutinefunction(functools.partial(regular_function)))
+
+        class PMClass:
+            def method(self, /):
+                pass
+
+            marked = inspect.markcoroutinefunction(
+                functools.partialmethod(method))
+            unmarked = functools.partialmethod(method)
+
+        self.assertTrue(inspect.iscoroutinefunction(PMClass.marked))
+        self.assertFalse(inspect.iscoroutinefunction(PMClass.unmarked))
+
     def test_isawaitable(self):
         def gen(): yield
         self.assertFalse(inspect.isawaitable(gen()))

Misc/NEWS.d/next/Library/2025-12-10-02-30-00.gh-issue-142418.j9Zka1.rst

@@ -0,0 +1,4 @@
+Fix ``inspect.iscoroutinefunction()`` incorrectly returning ``False`` for
+callables wrapped in ``functools.partial`` or ``functools.partialmethod`` when
+explicitly marked with ``inspect.markcoroutinefunction()``. The function now
+detects coroutine markers on wrappers at each unwrap stage.