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

{mode_streaming-0.5.1 → 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.1 → mode_streaming-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mode-streaming
-Version: 0.5.1
+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.1 → 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.1 → mode_streaming-0.5.3}/mode/utils/objects.py

@@ -366,11 +366,18 @@ def annotations(
                 )
             )
 
-    # Normalize all field types for forward refs
-    normalized_fields = {
-        k: _normalize_forwardref(v) for k, v in fields.items()
-    }
-    return normalized_fields, defaults
+    # NOTE: Return the resolved field types as-is. `_resolve_refs`/`eval_type`
+    # above already turned string/ForwardRef annotations into real types, so
+    # nothing further is needed here. Do NOT run `_normalize_forwardref` over
+    # the result: it rewrites any type whose ``__qualname__`` contains
+    # "<locals>" (i.e. every class defined inside a function) down to a bare
+    # ``__name__`` *string*, destroying the actual class object. Callers such
+    # as faust.Record rely on identity of the returned types (e.g. matching a
+    # field type against a custom coercion mapping), which silently breaks
+    # when the type is replaced by its name string. `_normalize_forwardref`
+    # remains available as a comparison helper for callers/tests that want a
+    # canonical, hashable-by-name form.
+    return fields, defaults
 
 
 def local_annotations(
@@ -453,6 +460,7 @@ def eval_type(
     """
     invalid_types = invalid_types or set()
     alias_types = alias_types or {}
+    original_str = typ if isinstance(typ, str) else None
     if isinstance(typ, str):
         typ = ForwardRef(typ)
     # `typing._eval_type` (imported above as `_eval_type`) already resolves
@@ -465,7 +473,30 @@ def eval_type(
     # attributes are not part of any stable API and are no longer present at
     # all on Python 3.14's ForwardRef, which raised AttributeError. mode's
     # floor is Python 3.9, well past the versions that workaround targeted).
-    typ = _eval_type(typ, globalns, localns)
+    if isinstance(typ, ForwardRef):
+        try:
+            typ = _eval_type(typ, globalns, localns)
+        except TypeError:
+            # `_eval_type` runs the forward ref through `typing._type_check`,
+            # which rejects `ClassVar[...]` with "is not valid as type
+            # argument". But a *string* ClassVar annotation is legitimate --
+            # `from __future__ import annotations` stringizes every
+            # annotation, ClassVars included -- and callers (see
+            # `_resolve_refs` + `skip_classvar`) still want to see it so they
+            # can drop it. Evaluate the forward arg directly and accept it
+            # when it is a ClassVar; otherwise re-raise the real error.
+            src = (
+                original_str
+                if original_str is not None
+                else typ.__forward_arg__
+            )
+            evaluated = eval(src, globalns, localns)  # noqa: S307
+            if _is_class_var(evaluated):
+                typ = evaluated
+            else:
+                raise
+    else:
+        typ = _eval_type(typ, globalns, localns)
     if typ in invalid_types:
         raise InvalidAnnotation(typ)
     return alias_types.get(typ, typ)

{mode_streaming-0.5.1 → 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.1
+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.1 → mode_streaming-0.5.3}/mode_streaming.egg-info/scm_version.json

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

{mode_streaming-0.5.1 → 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.1 → mode_streaming-0.5.3}/tests/unit/utils/test_objects.py

@@ -275,6 +275,38 @@ def test_annotations__stop_excludes_base_above_stop():
     assert fields == {"foo": int}
 
 
+def test_annotations__preserves_function_local_class_identity():
+    # Regression test: a field annotated with a class defined inside a
+    # function (``__qualname__`` contains "<locals>") must be returned as the
+    # actual class object, not rewritten to its bare name string. Callers
+    # such as faust.Record match a field's resolved type by identity against
+    # a coercion mapping, which silently breaks if the type is replaced by a
+    # string.
+    class Local:
+        value: int
+
+    class Holder:
+        item: Local
+
+    fields, _ = annotations(Holder, globalns=globals(), localns=locals())
+
+    assert fields["item"] is Local
+    assert not isinstance(fields["item"], str)
+
+
+def test_eval_type__string_classvar_is_not_rejected():
+    # Regression test: a *string* ClassVar annotation (as produced by
+    # `from __future__ import annotations`) must not raise. Passing the
+    # forward ref straight to typing._eval_type runs typing._type_check,
+    # which rejects ClassVar[...] with "is not valid as type argument".
+    from typing import ClassVar as _ClassVar
+
+    result = eval_type(
+        "ClassVar[int]", globalns={"ClassVar": _ClassVar}, localns={}
+    )
+    assert result == _ClassVar[int]
+
+
 @pytest.mark.parametrize(
     "input,expected",
     [

mode_streaming-0.5.1/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()