vsjetengine 1.3.0__tar.gz → 1.4.0__tar.gz

{vsjetengine-1.3.0 → vsjetengine-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vsjetengine
-Version: 1.3.0
+Version: 1.4.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.3.0 → vsjetengine-1.4.0}/tests/test_futures.py

@@ -141,9 +141,6 @@ def test_unified_future_catch() -> None:
 
 @pytest.mark.asyncio
 async def test_unified_future_add_loop_callback() -> None:
-    from vsengine.adapters.asyncio import AsyncIOLoop
-    from vsengine.loops import set_loop
-
     set_loop(AsyncIOLoop())
 
     def _init_thread(fut: Future[threading.Thread]) -> None:
@@ -170,6 +167,122 @@ async def test_unified_future_add_loop_callback() -> None:
     assert cb_thread != loop_thread
 
 
+@pytest.mark.asyncio
+async def test_unified_future_add_loop_callback_chaining() -> None:
+    set_loop(AsyncIOLoop())
+
+    fut = Future[int]()
+    unified_fut = UnifiedFuture.from_future(fut)
+
+    recorded_value: int | None = None
+
+    def _side_effect(f: Future[int]) -> None:
+        nonlocal recorded_value
+        recorded_value = f.result() * 2
+
+    chained_fut = unified_fut.add_loop_callback(_side_effect)
+
+    results = list[int]()
+    chained_fut.then(lambda val: results.append(val))
+
+    fut.set_result(21)
+
+    res = await chained_fut
+    assert res == 21
+    assert results == [21]
+    assert recorded_value == 42
+
+
+@pytest.mark.asyncio
+async def test_unified_future_then_on_loop() -> None:
+    set_loop(AsyncIOLoop())
+
+    fut = Future[int]()
+    unified_fut = UnifiedFuture.from_future(fut)
+
+    loop_thread: threading.Thread | None = None
+    callback_thread: threading.Thread | None = None
+
+    def _init_thread() -> None:
+        fut.set_result(42)
+
+    def _on_success(v: int) -> int:
+        nonlocal callback_thread
+        callback_thread = threading.current_thread()
+        return v * 2
+
+    chained = unified_fut.then(_on_success, on_loop=True)
+
+    thr = threading.Thread(target=_init_thread)
+    thr.start()
+
+    res = await chained
+    loop_thread = threading.current_thread()
+
+    assert callback_thread == loop_thread
+    assert res == 84
+
+
+@pytest.mark.asyncio
+async def test_unified_future_map_on_loop() -> None:
+    set_loop(AsyncIOLoop())
+
+    fut = Future[int]()
+    unified_fut = UnifiedFuture.from_future(fut)
+
+    loop_thread: threading.Thread | None = None
+    callback_thread: threading.Thread | None = None
+
+    def _init_thread() -> None:
+        fut.set_result(10)
+
+    def _map_fn(v: int) -> str:
+        nonlocal callback_thread
+        callback_thread = threading.current_thread()
+        return f"value: {v}"
+
+    chained = unified_fut.map(_map_fn, on_loop=True)
+
+    thr = threading.Thread(target=_init_thread)
+    thr.start()
+
+    res = await chained
+    loop_thread = threading.current_thread()
+
+    assert callback_thread == loop_thread
+    assert res == "value: 10"
+
+
+@pytest.mark.asyncio
+async def test_unified_future_catch_on_loop() -> None:
+    set_loop(AsyncIOLoop())
+
+    fut = Future[int]()
+    unified_fut = UnifiedFuture.from_future(fut)
+
+    loop_thread: threading.Thread | None = None
+    callback_thread: threading.Thread | None = None
+
+    def _init_thread() -> None:
+        fut.set_exception(ValueError("error!"))
+
+    def _catch_fn(e: BaseException) -> str:
+        nonlocal callback_thread
+        callback_thread = threading.current_thread()
+        return str(e)
+
+    chained = unified_fut.catch(_catch_fn, on_loop=True)
+
+    thr = threading.Thread(target=_init_thread)
+    thr.start()
+
+    res = await chained
+    loop_thread = threading.current_thread()
+
+    assert callback_thread == loop_thread
+    assert res == "error!"
+
+
 # UnifiedIterator tests
 
 

vsjetengine-1.4.0/vsengine/_version.py

@@ -0,0 +1,2 @@
+__version__ = "1.4.0"
+__version_tuple__ = (1, 4, 0)

{vsjetengine-1.3.0 → vsjetengine-1.4.0}/vsengine/futures.py

@@ -27,6 +27,10 @@ class AsyncFutureLike[V](Protocol):
     async def awaitable(self) -> V: ...
 
 
+type UnifiedFutureLike[T] = UnifiedFuture[T]
+type UnifiedIteratorLike[T] = UnifiedIterator[T]
+
+
 class UnifiedFuture[T](Future[T], AbstractContextManager[Any], AbstractAsyncContextManager[Any], Awaitable[T]):
     """
     A Promise-inspired Future that unifies concurrent.futures.Future
@@ -34,7 +38,12 @@ class UnifiedFuture[T](Future[T], AbstractContextManager[Any], AbstractAsyncCont
     """
 
     @classmethod
-    def from_call[**P](cls, func: Callable[P, Future[T]], *args: P.args, **kwargs: P.kwargs) -> Self:
+    def from_call[S, **P](
+        cls: type[UnifiedFutureLike[S]],
+        func: Callable[P, Future[S]],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> UnifiedFutureLike[S]:
         """
         Call `func` and wrap the returned `Future` as a `UnifiedFuture`.
 
@@ -54,7 +63,7 @@ class UnifiedFuture[T](Future[T], AbstractContextManager[Any], AbstractAsyncCont
         return cls.from_future(future)
 
     @classmethod
-    def from_future(cls, future: Future[T]) -> Self:
+    def from_future[S](cls: type[UnifiedFutureLike[S]], future: Future[S]) -> UnifiedFutureLike[S]:
         """
         Wrap an existing `Future` as a `UnifiedFuture`.
 
@@ -68,7 +77,7 @@ class UnifiedFuture[T](Future[T], AbstractContextManager[Any], AbstractAsyncCont
 
         result = cls()
 
-        def _receive(fn: Future[T]) -> None:
+        def _receive(fn: Future[S]) -> None:
             if (exc := future.exception()) is not None:
                 result.set_exception(exc)
             else:
@@ -78,7 +87,7 @@ class UnifiedFuture[T](Future[T], AbstractContextManager[Any], AbstractAsyncCont
         return result
 
     @classmethod
-    def resolve(cls, value: T) -> Self:
+    def resolve[S](cls: type[UnifiedFutureLike[S]], value: S) -> UnifiedFutureLike[S]:
         """
         Return an already-resolved `UnifiedFuture` carrying `value`.
 
@@ -90,7 +99,7 @@ class UnifiedFuture[T](Future[T], AbstractContextManager[Any], AbstractAsyncCont
         return future
 
     @classmethod
-    def reject(cls, error: BaseException) -> Self:
+    def reject(cls: type[UnifiedFutureLike[Any]], error: BaseException) -> UnifiedFutureLike[Any]:
         """
         Return an already-rejected `UnifiedFuture` carrying `error`.
 
@@ -114,7 +123,7 @@ 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]) -> None:
+    def add_loop_callback(self, func: Callable[[Future[T]], Any]) -> UnifiedFuture[T]:
         """
         Register a callback that is guaranteed to run on the event-loop thread.
 
@@ -122,25 +131,51 @@ 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.
+        :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:
-            get_loop().from_thread(func, future)
+            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())
+
+            loop_fut.add_done_callback(_forward)
 
         self.add_done_callback(_wrapper)
+        return result
 
     # Manipulating futures
     @overload
-    def then[S](self, success_cb: Callable[[T], S]) -> UnifiedFuture[S]: ...
+    def then[S](self, success_cb: Callable[[T], S], *, on_loop: bool = ...) -> UnifiedFuture[S]: ...
     @overload
-    def then[S](self, success_cb: Callable[[T], S], err_cb: None = ...) -> UnifiedFuture[S]: ...
+    def then[S](self, success_cb: Callable[[T], S], err_cb: None = ..., *, on_loop: bool = ...) -> UnifiedFuture[S]: ...
     @overload
-    def then[V](self, success_cb: None, err_cb: Callable[[BaseException], V]) -> UnifiedFuture[T | V]: ...
+    def then[V](self, success_cb: None, err_cb: Callable[[BaseException], V], *, on_loop: bool = ...) -> UnifiedFuture[T | V]: ...  # fmt: skip  # noqa: E501
     @overload
-    def then[V](self, *, err_cb: Callable[[BaseException], V]) -> UnifiedFuture[T | V]: ...
+    def then[V](self, *, err_cb: Callable[[BaseException], V], on_loop: bool = ...) -> UnifiedFuture[T | V]: ...
     @overload
-    def then[S, V](self, success_cb: Callable[[T], S], err_cb: Callable[[BaseException], V]) -> UnifiedFuture[S | V]: ...  # fmt: skip  # noqa: E501
-    def then[S, V](self, success_cb: Callable[[T], S] | None = None, err_cb: Callable[[BaseException], V] | None = None) -> Any:  # fmt: skip  # noqa: E501
+    def then[S, V](
+        self,
+        success_cb: Callable[[T], S],
+        err_cb: Callable[[BaseException], V],
+        *,
+        on_loop: bool = ...,
+    ) -> UnifiedFuture[S | V]: ...
+    def then[S, V](
+        self,
+        success_cb: Callable[[T], S] | None = None,
+        err_cb: Callable[[BaseException], V] | None = None,
+        *,
+        on_loop: bool = False,
+    ) -> Any:
         """
         Attach fulfilment and/or rejection handlers, returning a new future.
 
@@ -153,17 +188,29 @@ class UnifiedFuture[T](Future[T], AbstractContextManager[Any], AbstractAsyncCont
 
         :param success_cb: Called with the resolved value, or `None` to passthrough.
         :param err_cb: Called with the exception, or `None` to passthrough.
+        :param on_loop: If True, execute the callback on the main loop.
         :return: A new `UnifiedFuture` carrying the callback's return value.
         """
         result = UnifiedFuture[Any]()
 
         def _run_cb(cb: Callable[[Any], Any], v: T | BaseException) -> None:
-            try:
-                r = cb(v)
-            except Exception as e:
-                result.set_exception(e)
+            if on_loop:
+                loop_fut = get_loop().from_thread(cb, v)
+
+                def _forward(lf: Future[Any]) -> None:
+                    if (exc := lf.exception()) is not None:
+                        result.set_exception(exc)
+                    else:
+                        result.set_result(lf.result())
+
+                loop_fut.add_done_callback(_forward)
             else:
-                result.set_result(r)
+                try:
+                    r = cb(v)
+                except Exception as e:
+                    result.set_exception(e)
+                else:
+                    result.set_result(r)
 
         def _done(fn: Future[T]) -> None:
             if (exc := self.exception()) is not None:
@@ -180,23 +227,25 @@ class UnifiedFuture[T](Future[T], AbstractContextManager[Any], AbstractAsyncCont
         self.add_done_callback(_done)
         return result
 
-    def map[V](self, cb: Callable[[T], V]) -> UnifiedFuture[V]:
+    def map[V](self, cb: Callable[[T], V], *, on_loop: bool = False) -> UnifiedFuture[V]:
         """
         Transform the resolved value with `cb`, returning a new future.
 
         :param cb: A callable that transforms the resolved value.
+        :param on_loop: If True, execute the callback on the main loop.
         :return: A new `UnifiedFuture` carrying the transformed value.
         """
-        return self.then(cb, None)
+        return self.then(cb, None, on_loop=on_loop)
 
-    def catch[V](self, cb: Callable[[BaseException], V]) -> UnifiedFuture[T | V]:
+    def catch[V](self, cb: Callable[[BaseException], V], *, on_loop: bool = False) -> UnifiedFuture[T | V]:
         """
         Recover from a rejection by handling the exception with `cb`.
 
         :param cb: A callable that handles the exception and returns a recovery value.
+        :param on_loop: If True, execute the callback on the main loop.
         :return: A new `UnifiedFuture` carrying the recovery value on error, or the original resolved value on success.
         """
-        return self.then(None, cb)
+        return self.then(None, cb, on_loop=on_loop)
 
     # Nicer Syntax
     def __enter__[EnterT](self: FutureLike[AbstractContextManager[EnterT, Any]]) -> EnterT:
@@ -276,11 +325,16 @@ class UnifiedIterator[T](Iterator[T], AsyncIterator[T]):
         self.future_iterable = future_iterable
 
     @classmethod
-    def from_call[**P](cls, func: Callable[P, Iterator[Future[T]]], *args: P.args, **kwargs: P.kwargs) -> Self:
+    def from_call[S, **P](
+        cls: type[UnifiedIteratorLike[S]],
+        func: Callable[P, Iterator[Future[S]]],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> UnifiedIteratorLike[S]:
         """
         Call `func` and wrap the returned iterator as a `UnifiedIterator`.
 
-        :param func: A callable that returns an `Iterator[Future[T]]`.
+        :param func: A callable that returns an `Iterator[Future[S]]`.
         :param args: Positional arguments forwarded to `func`.
         :param kwargs: Keyword arguments forwarded to `func`.
         :return: A `UnifiedIterator` wrapping the returned iterator.

vsjetengine-1.3.0/vsengine/_version.py

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