fix(rtc): avoid deprecated asyncio.iscoroutinefunction in EventEmitter.on (#815)

Author: xbt-a4224j

livekit-rtc/livekit/rtc/event_emitter.py

@@ -1,9 +1,18 @@
-import inspect
 import asyncio
+import inspect
 from typing import Any, Callable, Dict, Set, Optional, Generic, TypeVar
 
 from .log import logger
 
+# `asyncio.iscoroutinefunction` also treats a callable tagged with this private
+# sentinel as a coroutine function (cpython/Lib/asyncio/coroutines.py:30-32);
+# `inspect.iscoroutinefunction` never has.
+# `@asyncio.coroutine` (removed in 3.11) applied the tag, but the sentinel itself
+# still exists on every version this package supports, so the check is kept on all
+# of them. Read defensively: it is private and may disappear with the deprecated
+# function in 3.16, and a bare attribute access would then fail at import time.
+_ASYNCIO_COROUTINE_MARKER = getattr(asyncio.coroutines, "_is_coroutine", None)
+
 T_contra = TypeVar("T_contra", contravariant=True)
 
 
@@ -157,7 +166,10 @@ def greet(name):
             ```
         """
         if callback is not None:
-            if asyncio.iscoroutinefunction(callback):
+            if inspect.iscoroutinefunction(callback) or (
+                _ASYNCIO_COROUTINE_MARKER is not None
+                and getattr(callback, "_is_coroutine", None) is _ASYNCIO_COROUTINE_MARKER
+            ):
                 raise ValueError(
                     "Cannot register an async callback with `.on()`. Use `asyncio.create_task` within your synchronous callback instead."
                 )

tests/rtc/test_emitter.py

@@ -1,7 +1,13 @@
-from livekit.rtc import EventEmitter
+import asyncio
+import functools
+import warnings
 from typing import Any, Literal
+from unittest.mock import AsyncMock
+
 import pytest
 
+from livekit.rtc import EventEmitter
+
 
 def test_events() -> None:
     EventTypes = Literal["connected", "reconnected", "disconnected"]
@@ -102,3 +108,79 @@ def on_error_another() -> None:
     emitter.emit("error")
 
     assert len(calls) == 2
+
+
+def test_on_does_not_warn() -> None:
+    """Registering a callback must not emit a DeprecationWarning.
+
+    `asyncio.iscoroutinefunction` is deprecated in Python 3.14 and slated for removal
+    in 3.16; `inspect.iscoroutinefunction` is the supported replacement.
+    """
+    EventTypes = Literal["connected"]
+
+    emitter = EventEmitter[EventTypes]()
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", DeprecationWarning)
+
+        @emitter.on("connected")
+        def on_connected() -> None:
+            pass
+
+        emitter.once("connected", on_connected)
+
+    emitter.emit("connected")
+
+
+def test_on_rejects_async_callback() -> None:
+    """`.on()` refuses coroutine functions, however they are spelled."""
+    EventTypes = Literal["connected"]
+
+    emitter = EventEmitter[EventTypes]()
+
+    async def on_connected() -> None:
+        pass
+
+    with pytest.raises(ValueError, match="Cannot register an async callback"):
+        emitter.on("connected", on_connected)
+
+    with pytest.raises(ValueError, match="Cannot register an async callback"):
+        emitter.on("connected", functools.partial(on_connected))
+
+
+def test_on_rejects_sentinel_tagged_callback() -> None:
+    """A callable tagged with asyncio's private coroutine sentinel is rejected.
+
+    `asyncio.iscoroutinefunction` honours this tag on every supported version;
+    `inspect.iscoroutinefunction` never has. `@asyncio.coroutine` (removed in
+    3.11) applied it, and `unittest.mock.AsyncMock` still does.
+    """
+    marker = getattr(asyncio.coroutines, "_is_coroutine", None)
+    if marker is None:
+        pytest.skip("asyncio.coroutines._is_coroutine is not defined on this Python")
+
+    EventTypes = Literal["connected"]
+
+    emitter = EventEmitter[EventTypes]()
+
+    def on_connected() -> None:
+        pass
+
+    on_connected._is_coroutine = marker  # type: ignore[attr-defined]
+
+    with pytest.raises(ValueError, match="Cannot register an async callback"):
+        emitter.on("connected", on_connected)
+
+
+def test_on_rejects_async_mock() -> None:
+    """`AsyncMock` is rejected on every supported version.
+
+    On Python 3.9, `inspect.iscoroutinefunction(AsyncMock())` is False; only the
+    sentinel check catches it.
+    """
+    EventTypes = Literal["connected"]
+
+    emitter = EventEmitter[EventTypes]()
+
+    with pytest.raises(ValueError, match="Cannot register an async callback"):
+        emitter.on("connected", AsyncMock())