mode-streaming 0.5.2__tar.gz → 0.5.3__tar.gz

{mode_streaming-0.5.2 → mode_streaming-0.5.3}/.github/workflows/tests.yml

@@ -26,10 +26,8 @@ jobs:
           - "3.11"
           - "3.12"
           - "3.13"
+          - "3.14"
         experimental: [ false ]
-        include:
-          - python-version: "~3.14.0-0"
-            experimental: true
 
     steps:
       - uses: actions/checkout@v3

{mode_streaming-0.5.2 → mode_streaming-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mode-streaming
-Version: 0.5.2
+Version: 0.5.3
 Summary: AsyncIO Service-based programming
 Author-email: Ask Solem Hoel <ask@robinhood.com>
 Maintainer-email: William Barnhart <williambbarnhart@gmail.com>
@@ -17,6 +17,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Operating System :: POSIX

{mode_streaming-0.5.2 → mode_streaming-0.5.3}/mode/utils/loops.py

@@ -1,10 +1,19 @@
 """Event loop utilities."""
 
 import asyncio
+import threading
 from typing import Any, Callable, Optional
 
 __all__ = ["call_asap", "clone_loop", "get_event_loop"]
 
+#: Per-thread cache of the loop resolved by :func:`get_event_loop` for when
+#: there is no *running* loop.  ``threading.local`` gives every thread its
+#: own attribute storage for free (no cross-thread leakage, no explicit
+#: cleanup required when a thread exits) -- required for correctness, not
+#: just performance, since Mode creates and runs a dedicated event loop per
+#: :class:`~mode.threads.ServiceThread` worker thread.
+_current_loop = threading.local()
+
 
 def get_event_loop() -> asyncio.AbstractEventLoop:
     """Return the current event loop, creating one if necessary.
@@ -20,17 +29,34 @@ def get_event_loop() -> asyncio.AbstractEventLoop:
     loop -- e.g. at import time, when agents/services are declared at module
     level -- so it needs the historical "get or create" semantics.  This
     restores them in a way that works across Python 3.9-3.14.
+
+    Whether a loop is currently *running* can change on every call (that's
+    the whole point of an event loop), so :func:`asyncio.get_running_loop`
+    must always be re-checked and can't be cached. When nothing is running,
+    though, the resolved loop is stable for the lifetime of the thread that
+    resolved it, so it's cached in thread-local storage: once a thread has
+    created (or found) its loop, later calls on that thread return the
+    cached reference directly instead of re-running the
+    ``asyncio.get_event_loop()``-raises-then-create dance every time.
     """
     try:
         return asyncio.get_running_loop()
     except RuntimeError:
         pass
+
+    loop: Optional[asyncio.AbstractEventLoop] = getattr(
+        _current_loop, "loop", None
+    )
+    if loop is not None and not loop.is_closed():
+        return loop
+
     try:
-        return asyncio.get_event_loop()
+        loop = asyncio.get_event_loop()
     except RuntimeError:
         loop = asyncio.new_event_loop()
         asyncio.set_event_loop(loop)
-        return loop
+    _current_loop.loop = loop
+    return loop
 
 
 def _is_unix_loop(loop: asyncio.AbstractEventLoop) -> bool:

{mode_streaming-0.5.2 → mode_streaming-0.5.3}/mode_streaming.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mode-streaming
-Version: 0.5.2
+Version: 0.5.3
 Summary: AsyncIO Service-based programming
 Author-email: Ask Solem Hoel <ask@robinhood.com>
 Maintainer-email: William Barnhart <williambbarnhart@gmail.com>
@@ -17,6 +17,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Operating System :: POSIX

{mode_streaming-0.5.2 → mode_streaming-0.5.3}/mode_streaming.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.2",
+  "tag": "0.5.3",
   "distance": 0,
-  "node": "g95118563cf82e6445e255bcf2fa7beeb1b23b5d3",
+  "node": "g9a3d6aeae585ec2ef1b322756c53c6f1af9b0bf2",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-07-19"

{mode_streaming-0.5.2 → mode_streaming-0.5.3}/pyproject.toml

@@ -40,6 +40,7 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Programming Language :: Python :: Implementation :: CPython",
     "Programming Language :: Python :: Implementation :: PyPy",
     "Operating System :: POSIX",

mode_streaming-0.5.3/tests/unit/utils/test_loops.py

@@ -0,0 +1,94 @@
+import asyncio
+import threading
+from unittest.mock import patch
+
+from mode.utils.loops import get_event_loop
+
+
+def test_get_event_loop__returns_running_loop_when_running():
+    async def main():
+        return get_event_loop()
+
+    running = asyncio.new_event_loop()
+    try:
+        got = running.run_until_complete(main())
+        assert got is running
+    finally:
+        running.close()
+
+
+def test_get_event_loop__reuses_current_loop_when_set():
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    try:
+        assert get_event_loop() is loop
+    finally:
+        asyncio.set_event_loop(None)
+        loop.close()
+
+
+def test_get_event_loop__creates_loop_when_none_set():
+    # Emulates Python 3.14, where asyncio.get_event_loop() no longer creates
+    # a loop implicitly and raises RuntimeError instead.
+    asyncio.set_event_loop(None)
+    loop = get_event_loop()
+    try:
+        assert isinstance(loop, asyncio.AbstractEventLoop)
+        assert asyncio.get_event_loop() is loop
+    finally:
+        asyncio.set_event_loop(None)
+        loop.close()
+
+
+def test_get_event_loop__is_idempotent_without_running_loop():
+    asyncio.set_event_loop(None)
+    first = get_event_loop()
+    try:
+        assert get_event_loop() is first
+    finally:
+        asyncio.set_event_loop(None)
+        first.close()
+
+
+def test_get_event_loop__caches_loop_without_repeated_lookup():
+    # The whole point of the thread-local cache: once a loop has been
+    # resolved for a thread, later calls on that thread must not re-invoke
+    # (and potentially re-raise/re-catch RuntimeError from)
+    # asyncio.get_event_loop() again.
+    asyncio.set_event_loop(None)
+    first = get_event_loop()
+    try:
+        with patch(
+            "mode.utils.loops.asyncio.get_event_loop"
+        ) as get_event_loop_mock:
+            second = get_event_loop()
+        assert second is first
+        get_event_loop_mock.assert_not_called()
+    finally:
+        asyncio.set_event_loop(None)
+        first.close()
+
+
+def test_get_event_loop__caches_per_thread_not_globally():
+    # Mode runs a dedicated event loop per ServiceThread worker thread
+    # (see mode.threads.ServiceThread), so the cache must be thread-local:
+    # one thread's cached loop must never leak into another thread's call.
+    asyncio.set_event_loop(None)
+    main_loop = get_event_loop()
+    other_loop_holder: dict = {}
+
+    def other_thread() -> None:
+        other_loop_holder["loop"] = get_event_loop()
+
+    try:
+        thread = threading.Thread(target=other_thread)
+        thread.start()
+        thread.join()
+
+        other_loop = other_loop_holder["loop"]
+        assert other_loop is not main_loop
+        assert get_event_loop() is main_loop
+    finally:
+        asyncio.set_event_loop(None)
+        main_loop.close()
+        other_loop_holder["loop"].close()

mode_streaming-0.5.2/tests/unit/utils/test_loops.py

@@ -1,48 +0,0 @@
-import asyncio
-
-from mode.utils.loops import get_event_loop
-
-
-def test_get_event_loop__returns_running_loop_when_running():
-    async def main():
-        return get_event_loop()
-
-    running = asyncio.new_event_loop()
-    try:
-        got = running.run_until_complete(main())
-        assert got is running
-    finally:
-        running.close()
-
-
-def test_get_event_loop__reuses_current_loop_when_set():
-    loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
-    try:
-        assert get_event_loop() is loop
-    finally:
-        asyncio.set_event_loop(None)
-        loop.close()
-
-
-def test_get_event_loop__creates_loop_when_none_set():
-    # Emulates Python 3.14, where asyncio.get_event_loop() no longer creates
-    # a loop implicitly and raises RuntimeError instead.
-    asyncio.set_event_loop(None)
-    loop = get_event_loop()
-    try:
-        assert isinstance(loop, asyncio.AbstractEventLoop)
-        assert asyncio.get_event_loop() is loop
-    finally:
-        asyncio.set_event_loop(None)
-        loop.close()
-
-
-def test_get_event_loop__is_idempotent_without_running_loop():
-    asyncio.set_event_loop(None)
-    first = get_event_loop()
-    try:
-        assert get_event_loop() is first
-    finally:
-        asyncio.set_event_loop(None)
-        first.close()