vsjetengine 1.6.2__tar.gz → 1.7.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: vsjetengine
-Version: 1.6.2
+Version: 1.7.0
 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.7.0}/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,243 @@ def test_unified_future_from_future_cancellation() -> None:
     assert uni.cancel() is True
     assert uni.cancelled() is True
     assert raw.cancelled() is True
+
+
+def test_unified_future_from_future_identity() -> None:
+    uni = UnifiedFuture.resolve(42)
+    assert UnifiedFuture.from_future(uni) is uni
+
+
+def test_unified_future_from_already_cancelled_future() -> None:
+    raw = Future[int]()
+    raw.cancel()
+    uni = UnifiedFuture.from_future(raw)
+    assert uni.cancelled() is True
+
+    loop = asyncio.new_event_loop()
+    raw_async = loop.create_future()
+    raw_async.cancel()
+    loop.close()
+    uni_async = UnifiedFuture.from_future(raw_async)
+    assert uni_async.cancelled() is True
+
+
+def test_unified_future_from_closed_asyncio_future() -> None:
+    loop = asyncio.new_event_loop()
+    raw = loop.create_future()
+    raw.set_result(42)
+    loop.close()
+
+    uni = UnifiedFuture.from_future(raw)
+
+    assert uni.result() == 42
+
+
+def test_unified_future_from_closed_asyncio_future_incomplete() -> None:
+    loop = asyncio.new_event_loop()
+    raw = loop.create_future()
+    loop.close()
+
+    uni = UnifiedFuture.from_future(raw)
+    assert uni.cancelled() is True
+
+
+def test_unified_future_from_closed_asyncio_future_exception() -> None:
+    loop = asyncio.new_event_loop()
+    raw = loop.create_future()
+    raw.set_exception(ValueError("closed error"))
+    loop.close()
+
+    uni = UnifiedFuture.from_future(raw)
+    assert isinstance(uni.exception(), ValueError)
+
+
+def test_unified_future_cancellation_propagates_to_closed_asyncio_future() -> None:
+    loop = asyncio.new_event_loop()
+    raw = loop.create_future()
+    uni = UnifiedFuture.from_future(raw)
+    loop.close()
+
+    assert uni.cancel() is True
+    assert raw.cancelled() is True
+
+
+@pytest.mark.asyncio
+async def test_unified_future_cancellation_prevents_asyncio_task_from_running() -> None:
+    ran = False
+
+    async def source() -> int:
+        nonlocal ran
+        ran = True
+        return 42
+
+    raw = asyncio.create_task(source())
+    uni = UnifiedFuture.from_future(raw)
+
+    assert uni.cancel() is True
+    await asyncio.sleep(0)
+
+    assert raw.cancelled() is True
+    assert ran is False
+
+
+@pytest.mark.asyncio
+async def test_unified_future_from_asyncio_future_exception() -> None:
+    set_loop(AsyncIOLoop())
+    raw = asyncio.get_running_loop().create_future()
+    uni = UnifiedFuture.from_future(raw)
+    raw.set_exception(ZeroDivisionError("division by zero"))
+
+    with pytest.raises(ZeroDivisionError):
+        await uni
+
+
+def test_unified_future_from_asyncio_foreign_thread() -> None:
+    loop = asyncio.new_event_loop()
+    t = threading.Thread(target=loop.run_forever, daemon=True)
+    t.start()
+
+    try:
+        fut = loop.create_future()
+        uni = UnifiedFuture[str].from_future(fut)
+
+        loop.call_soon_threadsafe(fut.set_result, "cross-thread-result")
+        assert uni.result(timeout=2.0) == "cross-thread-result"
+    finally:
+        loop.call_soon_threadsafe(loop.stop)
+        t.join()
+        loop.close()
+
+
+def test_unified_future_from_asyncio_foreign_thread_cancellation() -> None:
+    loop = asyncio.new_event_loop()
+    t = threading.Thread(target=loop.run_forever, daemon=True)
+    t.start()
+
+    try:
+        fut = loop.create_future()
+        uni = UnifiedFuture[str].from_future(fut)
+
+        assert uni.cancel() is True
+        assert uni.cancelled() is True
+
+        ev = threading.Event()
+        loop.call_soon_threadsafe(ev.set)
+        assert ev.wait(timeout=2.0)
+
+        assert fut.cancelled() is True
+    finally:
+        loop.call_soon_threadsafe(loop.stop)
+        t.join()
+        loop.close()
+
+
+def test_unified_future_from_asyncio_concurrent_close_done(monkeypatch: pytest.MonkeyPatch) -> None:
+    loop = asyncio.new_event_loop()
+    fut = loop.create_future()
+    fut.set_result(123)
+
+    def fake_call_soon_threadsafe(*args: Any, **kwargs: Any) -> None:
+        raise RuntimeError("Event loop is closed")
+
+    monkeypatch.setattr(loop, "call_soon_threadsafe", fake_call_soon_threadsafe)
+
+    uni = UnifiedFuture.from_future(fut)
+    assert uni.result() == 123
+
+
+def test_unified_future_from_asyncio_concurrent_close_incomplete(monkeypatch: pytest.MonkeyPatch) -> None:
+    loop = asyncio.new_event_loop()
+    fut = loop.create_future()
+
+    def fake_call_soon_threadsafe(*args: Any, **kwargs: Any) -> None:
+        raise RuntimeError("Event loop is closed")
+
+    monkeypatch.setattr(loop, "call_soon_threadsafe", fake_call_soon_threadsafe)
+
+    uni = UnifiedFuture.from_future(fut)
+    assert uni.cancelled() is True
+
+
+def test_unified_future_from_asyncio_concurrent_close_cancellation(monkeypatch: pytest.MonkeyPatch) -> None:
+    loop = asyncio.new_event_loop()
+    fut = loop.create_future()
+    uni = UnifiedFuture.from_future(fut)
+
+    def fake_call_soon_threadsafe(*args: Any, **kwargs: Any) -> None:
+        raise RuntimeError("Event loop is closed")
+
+    monkeypatch.setattr(loop, "call_soon_threadsafe", fake_call_soon_threadsafe)
+
+    assert uni.cancel() 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.2 → vsjetengine-1.7.0}/tests/test_loop_adapters.py

@@ -9,6 +9,8 @@ from __future__ import annotations
 
 import asyncio
 import contextlib
+import contextvars
+import functools
 import threading
 import unittest.mock
 from collections.abc import Awaitable, Callable, Generator, Iterator
@@ -311,19 +313,90 @@ class TestTrio(AsyncAdapterTest):
             yield
 
 
-def test_asyncio_from_thread_without_running_loop() -> None:
-    """Ensure AsyncIOLoop gracefully executes inline when no asyncio loop is running."""
+def test_asyncio_methods_without_running_loop() -> None:
+    """Ensure AsyncIOLoop raises RuntimeError when no asyncio loop is running."""
     loop = AsyncIOLoop()
-    fut = loop.from_thread(lambda x: x * 2, 21)
-    assert fut.done()
-    assert fut.result() == 42
+    with pytest.raises(RuntimeError, match="No running asyncio event loop"):
+        loop.from_thread(lambda x: x * 2, 21)
 
+    with pytest.raises(RuntimeError, match="No running asyncio event loop"):
+        loop.to_thread(lambda x: x * 2, 21)
 
-def test_trio_from_thread_without_running_token() -> None:
-    """Ensure TrioEventLoop gracefully executes inline when no Trio token is active."""
+    with pytest.raises(RuntimeError, match="No running asyncio event loop"):
+        loop.next_cycle()
+
+
+def test_trio_methods_without_running_token() -> None:
+    """Ensure TrioEventLoop raises RuntimeError when no Trio token or nursery is active."""
+    loop = TrioEventLoop()
+    with pytest.raises(RuntimeError, match="No running Trio event loop"):
+        loop.from_thread(lambda x: x + 1, 10)
+
+    with pytest.raises(RuntimeError, match="Trio nursery is not set"):
+        loop.to_thread(lambda x: x + 1, 10)
+
+    with pytest.raises(RuntimeError, match="No running Trio event loop"):
+        loop.next_cycle()
+
+
+def test_trio_from_thread_contextvars() -> None:
+    """Ensure TrioEventLoop propagates contextvars from the calling thread."""
+    var: contextvars.ContextVar[str] = contextvars.ContextVar("var", default="default")
+
+    async def main() -> None:
+        async with trio.open_nursery() as nursery:
+            loop = TrioEventLoop(nursery)
+            results = list[str]()
+
+            def worker() -> None:
+                var.set("custom_val")
+                fut = loop.from_thread(var.get)
+                results.append(fut.result(timeout=0.5))
+
+            await trio.to_thread.run_sync(worker)
+            assert results == ["custom_val"]
+
+    trio.run(main)
+
+
+def test_to_thread_with_partial() -> None:
+    """Ensure to_thread handles functools.partial and callables without __name__."""
+
+    def add(a: int, b: int) -> int:
+        return a + b
+
+    part = functools.partial(add, 10, 20)
+
+    # Test with TrioEventLoop
+    async def trio_main() -> None:
+        async with trio.open_nursery() as nursery:
+            loop = TrioEventLoop(nursery)
+            fut = loop.to_thread(part)
+            while not fut.done():
+                await trio.sleep(0.01)
+            assert fut.result() == 30
+
+    trio.run(trio_main)
+
+    # Test with AsyncIOLoop
+    async def asyncio_main() -> None:
+        loop = AsyncIOLoop()
+        fut = loop.to_thread(part)
+        while not fut.done():
+            await asyncio.sleep(0.01)
+        assert fut.result() == 30
+
+    asyncio.run(asyncio_main())
+
+
+def test_trio_detach_lifecycle() -> None:
+    """Ensure detach cleanly resets token and limiter."""
     nursery = unittest.mock.MagicMock()
-    nursery.cancel_scope.cancel_called = False
     loop = TrioEventLoop(nursery)
-    fut = loop.from_thread(lambda x: x + 1, 10)
-    assert fut.done()
-    assert fut.result() == 11
+    loop.token = unittest.mock.MagicMock()
+    loop.limiter = unittest.mock.MagicMock()
+
+    loop.detach()
+    nursery.cancel_scope.cancel.assert_called_once()
+    assert loop._token is None
+    assert loop._limiter is None

vsjetengine-1.7.0/vsengine/_version.py

@@ -0,0 +1,2 @@
+__version__ = "1.7.0"
+__version_tuple__ = (1, 7, 0)

{vsjetengine-1.6.2 → vsjetengine-1.7.0}/vsengine/adapters/asyncio.py

@@ -20,6 +20,9 @@ class AsyncIOLoop(EventLoop):
 
     def __init__(self, loop: asyncio.AbstractEventLoop | None = None) -> None:
         self._loop = loop
+        if self._loop is None:
+            with contextlib.suppress(RuntimeError):
+                self._loop = asyncio.get_running_loop()
 
     @property
     def loop(self) -> asyncio.AbstractEventLoop | None:
@@ -43,6 +46,9 @@ class AsyncIOLoop(EventLoop):
         self._loop = None
 
     def from_thread[**P, R](self, func: Callable[P, R], *args: P.args, **kwargs: P.kwargs) -> Future[R]:
+        if (loop := self.loop) is None or loop.is_closed():
+            raise RuntimeError("No running asyncio event loop or loop is closed.")
+
         future = Future[R]()
 
         def wrap() -> Future[R]:
@@ -58,32 +64,32 @@ class AsyncIOLoop(EventLoop):
 
             return future
 
-        if (loop := self.loop) is None or loop.is_closed():
-            return wrap()
-
         loop.call_soon_threadsafe(wrap, context=contextvars.copy_context())
         return future
 
     def to_thread[**P, R](self, func: Callable[P, R], *args: P.args, **kwargs: P.kwargs) -> Future[R]:
         if (loop := self.loop) is None or loop.is_closed():
-            return super().to_thread(func, *args, **kwargs)
+            raise RuntimeError("No running asyncio event loop or loop is closed.")
 
         future = Future[R]()
 
         async def run() -> None:
+            if not future.set_running_or_notify_cancel():
+                return
+
             try:
-                result = await asyncio.to_thread(lambda: func(*args, **kwargs))
+                result = await asyncio.to_thread(func, *args, **kwargs)
             except BaseException as e:
                 future.set_exception(e)
             else:
                 future.set_result(result)
 
-        loop.create_task(run(), name=func.__name__, context=contextvars.copy_context())
+        loop.create_task(run(), name=getattr(func, "__name__", None), context=contextvars.copy_context())
         return future
 
     def next_cycle(self) -> Future[None]:
         if (loop := self.loop) is None or loop.is_closed():
-            return super().next_cycle()
+            raise RuntimeError("No running asyncio event loop or loop is closed.")
 
         future = Future[None]()
         task = asyncio.current_task(loop)
@@ -97,7 +103,7 @@ class AsyncIOLoop(EventLoop):
         loop.call_soon(continuation)
         return future
 
-    async def await_future[T](self, future: Future[T]) -> T:
+    async def await_future[T](self, future: Future[T] | asyncio.Future[T]) -> T:
         with self.wrap_cancelled():
             return await asyncio.wrap_future(future)
 
@@ -106,4 +112,4 @@ class AsyncIOLoop(EventLoop):
         try:
             yield
         except Cancelled:
-            raise asyncio.CancelledError() from None
+            raise asyncio.CancelledError from None

{vsjetengine-1.6.2 → vsjetengine-1.7.0}/vsengine/adapters/trio.py

@@ -7,6 +7,7 @@
 from __future__ import annotations
 
 import contextlib
+import contextvars
 from collections.abc import Callable, Generator
 from concurrent.futures import Future
 
@@ -20,10 +21,12 @@ class TrioEventLoop(EventLoop):
     Bridges vs-engine to Trio.
     """
 
-    def __init__(self, nursery: trio.Nursery, limiter: trio.CapacityLimiter | None = None) -> None:
+    def __init__(self, nursery: trio.Nursery | None = None, limiter: trio.CapacityLimiter | None = None) -> None:
         self.nursery = nursery
         self._limiter = limiter
         self._token: trio.lowlevel.TrioToken | None = None
+        with contextlib.suppress(RuntimeError):
+            self._token = trio.lowlevel.current_trio_token()
 
     @property
     def limiter(self) -> trio.CapacityLimiter | None:
@@ -56,9 +59,16 @@ class TrioEventLoop(EventLoop):
             self._token = trio.lowlevel.current_trio_token()
 
     def detach(self) -> None:
-        self.nursery.cancel_scope.cancel()
+        if self.nursery is not None:
+            with contextlib.suppress(RuntimeError):
+                self.nursery.cancel_scope.cancel()
+        self._token = None
+        self._limiter = None
 
     def from_thread[**P, R](self, func: Callable[P, R], *args: P.args, **kwargs: P.kwargs) -> Future[R]:
+        if (token := self.token) is None:
+            raise RuntimeError("No running Trio event loop or token is inactive.")
+
         future = Future[R]()
 
         def executor() -> Future[R]:
@@ -73,37 +83,58 @@ class TrioEventLoop(EventLoop):
                 future.set_result(result)
             return future
 
-        if token := self.token:
-            token.run_sync_soon(executor)
-            return future
+        try:
+            token.run_sync_soon(contextvars.copy_context().run, executor)
+        except (trio.RunFinishedError, trio.ClosedResourceError) as e:
+            self._token = None
+            raise RuntimeError("Trio event loop has already finished or is closed.") from e
 
-        return executor()
+        return future
 
     def to_thread[**P, R](self, func: Callable[P, R], *args: P.args, **kwargs: P.kwargs) -> Future[R]:
+        if self.nursery is None:
+            raise RuntimeError("Trio nursery is not set.")
         if self.nursery.cancel_scope.cancel_called:
-            return super().to_thread(func, *args, **kwargs)
+            raise RuntimeError("Trio nursery has been cancelled.")
 
         future = Future[R]()
 
         async def run() -> None:
             def executor() -> None:
+                if not future.set_running_or_notify_cancel():
+                    return
+
                 try:
                     result = func(*args, **kwargs)
-                    future.set_result(result)
                 except BaseException as e:
                     future.set_exception(e)
+                else:
+                    future.set_result(result)
 
-            await trio.to_thread.run_sync(executor, limiter=self.limiter)
+            try:
+                await trio.to_thread.run_sync(executor, limiter=self.limiter)
+            except BaseException as e:
+                if not future.done():
+                    future.set_exception(Cancelled() if isinstance(e, trio.Cancelled) else e)
+                raise
+
+        try:
+            self.nursery.start_soon(run, name=getattr(func, "__name__", None))
+        except RuntimeError as e:
+            raise RuntimeError("Trio nursery is closed or cannot start tasks.") from e
 
-        self.nursery.start_soon(run, name=func.__name__)
         return future
 
     def next_cycle(self) -> Future[None]:
-        scope = trio.CancelScope()
+        if self.token is None:
+            raise RuntimeError("No running Trio event loop or token is inactive.")
+        if self.nursery is None or self.nursery.cancel_scope.cancel_called:
+            raise RuntimeError("Trio nursery is not set or has been cancelled.")
+
         future = Future[None]()
 
         def continuation() -> None:
-            if scope.cancel_called:
+            if self.nursery is not None and self.nursery.cancel_scope.cancel_called:
                 future.set_exception(Cancelled())
             else:
                 future.set_result(None)
@@ -112,6 +143,13 @@ class TrioEventLoop(EventLoop):
         return future
 
     async def await_future[T](self, future: Future[T]) -> T:
+        if future.done():
+            try:
+                return future.result()
+            except BaseException:
+                with self.wrap_cancelled():
+                    raise
+
         event = trio.Event()
 
         def _when_done(_: Future[T]) -> None:

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

@@ -5,10 +5,12 @@
 # SPDX-License-Identifier: EUPL-1.2
 from __future__ import annotations
 
+import asyncio
+import contextvars
 import traceback
 from collections.abc import AsyncIterator, Awaitable, Callable, Generator, Iterator
-from concurrent.futures import Future
-from contextlib import AbstractAsyncContextManager, AbstractContextManager
+from concurrent.futures import CancelledError, Future
+from contextlib import AbstractAsyncContextManager, AbstractContextManager, suppress
 from functools import wraps
 from inspect import isgeneratorfunction
 from types import TracebackType
@@ -63,7 +65,7 @@ class UnifiedFuture[T](Future[T], AbstractContextManager[Any], AbstractAsyncCont
         return cls.from_future(future)
 
     @classmethod
-    def from_future[S](cls: type[UnifiedFutureLike[S]], future: Future[S]) -> UnifiedFutureLike[S]:
+    def from_future[S](cls: type[UnifiedFutureLike[S]], future: Future[S] | asyncio.Future[S]) -> UnifiedFutureLike[S]:
         """
         Wrap an existing `Future` as a `UnifiedFuture`.
 
@@ -77,17 +79,47 @@ class UnifiedFuture[T](Future[T], AbstractContextManager[Any], AbstractAsyncCont
 
         result = cls()
 
-        def _receive(fn: Future[S]) -> None:
+        def receive(_: Future[S] | asyncio.Future[S]) -> None:
+            if result.done():
+                return
             if future.cancelled():
                 result.cancel()
                 return
-            if (exc := future.exception()) is not None:
+            try:
+                exc = future.exception()
+            except (CancelledError, asyncio.CancelledError):
+                # Catch any cancellation race condition
+                result.cancel()
+                return
+
+            if exc is not None:
                 result.set_exception(exc)
-            elif not result.cancelled():
+            else:
                 result.set_result(future.result())
 
-        future.add_done_callback(_receive)
-        result.add_done_callback(lambda f: future.cancel() if f.cancelled() else None)
+        # Safely propagate cancellation back to the original future
+        def on_result_cancelled(f: Future[S]) -> None:
+            if not f.cancelled() or future.done():
+                return
+
+            if isinstance(future, asyncio.Future):
+                cls._dispatch_to_loop(future, future.cancel)
+            else:
+                future.cancel()
+
+        result.add_done_callback(on_result_cancelled)
+
+        # Safely register the completion callback
+        if isinstance(future, asyncio.Future):
+            cls._dispatch_to_loop(
+                future,
+                future.add_done_callback,
+                receive,
+                on_closed_done=receive,
+                on_closed_incomplete=result.cancel,
+            )
+        else:
+            future.add_done_callback(receive)
         return result
 
     @classmethod
@@ -127,7 +159,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 +171,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 +266,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 +279,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 +393,83 @@ class UnifiedFuture[T](Future[T], AbstractContextManager[Any], AbstractAsyncCont
 
         raise NotImplementedError("(async) with is not implemented for this object")
 
+    @staticmethod
+    def _dispatch_to_loop[*Ts](
+        fut: asyncio.Future[Any],
+        action: Callable[[*Ts], Any],
+        *args: *Ts,
+        on_closed_done: Callable[[asyncio.Future[Any]], Any] | None = None,
+        on_closed_incomplete: Callable[[], Any] | None = None,
+    ) -> None:
+        f_loop = fut.get_loop()
+        try:
+            current_loop = asyncio.get_running_loop()
+        except RuntimeError:
+            current_loop = None
+
+        if current_loop is f_loop:
+            action(*args)
+        elif f_loop.is_closed():
+            if fut.done() and on_closed_done:
+                on_closed_done(fut)
+            elif on_closed_incomplete:
+                on_closed_incomplete()
+            else:
+                with suppress(RuntimeError):
+                    action(*args)
+        else:
+            try:
+                f_loop.call_soon_threadsafe(action, *args, context=contextvars.copy_context())
+            except RuntimeError:
+                # Loop closed concurrently
+                if fut.done() and on_closed_done is not None:
+                    on_closed_done(fut)
+                elif on_closed_incomplete is not None:
+                    on_closed_incomplete()
+                else:
+                    with suppress(RuntimeError):
+                        action(*args)
+
+    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)