vsjetengine 1.6.2__tar.gz → 1.6.3__tar.gz

{vsjetengine-1.6.2 → vsjetengine-1.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: vsjetengine
-Version: 1.6.2
+Version: 1.6.3
 Summary: An engine for vapoursynth previewers, renderers and script analyis tools.
 Project-URL: Source Code, https://github.com/Jaded-Encoding-Thaumaturgy/vs-jet-engine
 Project-URL: Contact, https://discord.gg/XTpc6Fa9eB

{vsjetengine-1.6.2 → vsjetengine-1.6.3}/tests/test_futures.py

@@ -5,6 +5,7 @@
 # SPDX-License-Identifier: EUPL-1.2
 """Tests for the unified future system."""
 
+import asyncio
 import contextlib
 import threading
 from collections.abc import AsyncGenerator, Generator, Iterator
@@ -741,3 +742,74 @@ def test_unified_future_from_future_cancellation() -> None:
     assert uni.cancel() is True
     assert uni.cancelled() is True
     assert raw.cancelled() is True
+
+
+@pytest.mark.asyncio
+async def test_unified_future_add_loop_callback_cancellation_propagation() -> None:
+    set_loop(AsyncIOLoop())
+    raw = UnifiedFuture[int]()
+    chained = raw.add_loop_callback(lambda f: None)
+
+    assert chained.cancel() is True
+    assert chained.cancelled() is True
+    assert raw.cancelled() is True
+
+
+@pytest.mark.asyncio
+async def test_unified_future_add_loop_callback_custom_on_cancel() -> None:
+    set_loop(AsyncIOLoop())
+    cancelled_calls = list[threading.Thread]()
+    loop_thread = threading.current_thread()
+    raw = UnifiedFuture[int]()
+    chained = raw.add_loop_callback(
+        lambda f: None,
+        cancel_cb=lambda: cancelled_calls.append(threading.current_thread()),
+    )
+
+    assert chained.cancel() is True
+    assert chained.cancelled() is True
+    await asyncio.sleep(0.01)
+    assert cancelled_calls == [loop_thread]
+    assert raw.cancelled() is False
+
+
+@pytest.mark.asyncio
+async def test_unified_future_then_custom_on_cancel_on_loop() -> None:
+    set_loop(AsyncIOLoop())
+    cancelled_calls = list[threading.Thread]()
+    loop_thread = threading.current_thread()
+    raw = UnifiedFuture[int]()
+    chained = raw.then(
+        lambda x: x * 2,
+        cancel_cb=lambda: cancelled_calls.append(threading.current_thread()),
+        on_loop=True,
+    )
+
+    # Cancel from a background thread
+    t = threading.Thread(target=chained.cancel)
+    t.start()
+    t.join()
+
+    await asyncio.sleep(0.01)
+    assert chained.cancelled() is True
+    assert cancelled_calls == [loop_thread]
+    assert raw.cancelled() is False
+
+
+@pytest.mark.asyncio
+async def test_unified_future_add_loop_callback_parent_cancelled() -> None:
+    set_loop(AsyncIOLoop())
+    raw = UnifiedFuture[int]()
+    called = list[bool]()
+
+    def cb(f: Future[int]) -> None:
+        called.append(f.cancelled())
+
+    chained = raw.add_loop_callback(cb)
+    raw.cancel()
+
+    with pytest.raises(asyncio.CancelledError):
+        await chained
+
+    assert chained.cancelled() is True
+    assert called == [True]

vsjetengine-1.6.3/vsengine/_version.py

@@ -0,0 +1,2 @@
+__version__ = "1.6.3"
+__version_tuple__ = (1, 6, 3)

{vsjetengine-1.6.2 → vsjetengine-1.6.3}/vsengine/futures.py

@@ -127,7 +127,11 @@ class UnifiedFuture[T](Future[T], AbstractContextManager[Any], AbstractAsyncCont
         # The done_callback should inherit the environment of the current call.
         super().add_done_callback(keep_environment(fn))
 
-    def add_loop_callback(self, func: Callable[[Future[T]], Any]) -> UnifiedFuture[T]:
+    def add_loop_callback(
+        self,
+        func: Callable[[Future[T]], Any],
+        cancel_cb: Callable[[], None] | None = None,
+    ) -> UnifiedFuture[T]:
         """
         Register a callback that is guaranteed to run on the event-loop thread.
 
@@ -135,25 +139,28 @@ class UnifiedFuture[T](Future[T], AbstractContextManager[Any], AbstractAsyncCont
         this method marshals `func` back to the main event loop via `EventLoop.from_thread`.
 
         :param func: A callable that receives the completed future.
+        :param cancel_cb: Optional callback invoked when the returned future is cancelled.
+            Defaults to cancelling the parent future.
         :return: A UnifiedFuture that resolves to the original future's result once the callback completes
             on the event loop.
         """
         result = UnifiedFuture[T]()
 
-        def _wrapper(future: Future[T]) -> None:
-            loop_fut = get_loop().from_thread(func, future)
-
-            def _forward(lf: Future[Any]) -> None:
-                if (exc := lf.exception()) is not None:
-                    result.set_exception(exc)
-                elif (orig_exc := future.exception()) is not None:
-                    result.set_exception(orig_exc)
-                else:
-                    result.set_result(future.result())
+        def forward_parent(_: Future[Any]) -> None:
+            if self.cancelled():
+                result.cancel()
+            elif (orig_exc := self.exception()) is not None:
+                result.set_exception(orig_exc)
+            else:
+                result.set_result(self.result())
 
-            loop_fut.add_done_callback(_forward)
+        def wrapper(future: Future[T]) -> None:
+            if result.cancelled():
+                return
+            self._forward_loop_task(get_loop().from_thread(func, future), result, forward_parent)
 
-        self.add_done_callback(_wrapper)
+        self.add_done_callback(wrapper)
+        self._link_cancellation(result, cancel_cb, on_loop=True)
         return result
 
     # Manipulating futures
@@ -227,23 +234,11 @@ class UnifiedFuture[T](Future[T], AbstractContextManager[Any], AbstractAsyncCont
         """
         result = UnifiedFuture[Any]()
 
-        def _run_cb(cb: Callable[[Any], Any], v: T | BaseException) -> None:
+        def run_cb(cb: Callable[[Any], Any], v: T | BaseException) -> None:
             if result.cancelled():
                 return
             if on_loop:
-                loop_fut = get_loop().from_thread(cb, v)
-
-                def _forward(lf: Future[Any]) -> None:
-                    if result.cancelled():
-                        return
-                    if lf.cancelled():
-                        result.cancel()
-                    elif (exc := lf.exception()) is not None:
-                        result.set_exception(exc)
-                    else:
-                        result.set_result(lf.result())
-
-                loop_fut.add_done_callback(_forward)
+                self._forward_loop_task(get_loop().from_thread(cb, v), result)
             else:
                 try:
                     r = cb(v)
@@ -252,26 +247,23 @@ class UnifiedFuture[T](Future[T], AbstractContextManager[Any], AbstractAsyncCont
                 else:
                     result.set_result(r)
 
-        def _done(fn: Future[T]) -> None:
+        def done(_: Future[T]) -> None:
             if self.cancelled():
                 result.cancel()
                 return
             if (exc := self.exception()) is not None:
                 if err_cb is not None:
-                    _run_cb(err_cb, exc)
+                    run_cb(err_cb, exc)
                 else:
                     result.set_exception(exc)
             elif not result.cancelled():
                 if success_cb is not None:
-                    _run_cb(success_cb, self.result())
+                    run_cb(success_cb, self.result())
                 else:
                     result.set_result(self.result())
 
-        self.add_done_callback(_done)
-        if cancel_cb is not None:
-            result.add_done_callback(lambda f: cancel_cb() if f.cancelled() else None)
-        else:
-            result.add_done_callback(lambda f: self.cancel() if f.cancelled() else None)
+        self.add_done_callback(done)
+        self._link_cancellation(result, cancel_cb, on_loop=on_loop)
         return result
 
     def map[V](
@@ -369,6 +361,46 @@ class UnifiedFuture[T](Future[T], AbstractContextManager[Any], AbstractAsyncCont
 
         raise NotImplementedError("(async) with is not implemented for this object")
 
+    def _link_cancellation(
+        self,
+        target: Future[Any],
+        cancel_cb: Callable[[], None] | None = None,
+        *,
+        on_loop: bool = False,
+    ) -> None:
+        if cancel_cb is not None:
+
+            def on_cancel(f: Future[Any]) -> None:
+                if f.cancelled():
+                    if on_loop:
+                        get_loop().from_thread(cancel_cb)
+                    else:
+                        cancel_cb()
+
+            target.add_done_callback(on_cancel)
+        else:
+            target.add_done_callback(lambda f: self.cancel() if f.cancelled() else None)
+
+    @staticmethod
+    def _forward_loop_task(
+        loop_fut: Future[Any],
+        target: UnifiedFuture[Any],
+        on_done: Callable[[Future[Any]], None] | None = None,
+    ) -> None:
+        def forward(lf: Future[Any]) -> None:
+            if target.cancelled():
+                return
+            if lf.cancelled():
+                target.cancel()
+            elif (exc := lf.exception()) is not None:
+                target.set_exception(exc)
+            elif on_done is not None:
+                on_done(lf)
+            else:
+                target.set_result(lf.result())
+
+        loop_fut.add_done_callback(forward)
+
 
 class UnifiedIterator[T](Iterator[T], AsyncIterator[T]):
     """

vsjetengine-1.6.2/vsengine/_version.py

@@ -1,2 +0,0 @@
-__version__ = "1.6.2"
-__version_tuple__ = (1, 6, 2)