vsjetengine 1.6.0__tar.gz → 1.6.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: vsjetengine
-Version: 1.6.0
+Version: 1.6.2
 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.0 → vsjetengine-1.6.2}/tests/test_futures.py

@@ -118,33 +118,33 @@ def test_unified_future_map() -> None:
     def _crash(v: Any) -> str:
         raise RuntimeError(str(v))
 
-    future = UnifiedFuture.from_call(succeeds)
-    new_future = future.map(lambda v: str(v))
-    assert new_future.result() == "1"
+    future0 = UnifiedFuture.from_call(succeeds)
+    new_future0 = future0.map(lambda v: str(v))
+    assert new_future0.result() == "1"
 
-    new_future = future.map(_crash)
-    assert isinstance(new_future.exception(), RuntimeError)
+    new_future0 = future0.map(_crash)
+    assert isinstance(new_future0.exception(), RuntimeError)
 
-    future = UnifiedFuture.from_call(fails)
-    new_future = future.map(lambda v: str(v))
-    assert isinstance(new_future.exception(), RuntimeError)
+    future1 = UnifiedFuture.from_call(fails)
+    new_future1 = future1.map(lambda v: str(v))
+    assert isinstance(new_future1.exception(), RuntimeError)
 
 
 def test_unified_future_catch() -> None:
     def _crash(_: BaseException) -> str:
         raise RuntimeError("test")
 
-    future = UnifiedFuture.from_call(fails)
-    new_future = future.catch(lambda e: e.__class__.__name__)
-    assert new_future.result() == "RuntimeError"
+    future0 = UnifiedFuture.from_call(fails)
+    new_future0 = future0.catch(lambda e: e.__class__.__name__)
+    assert new_future0.result() == "RuntimeError"
 
-    new_future = future.catch(_crash)
-    assert isinstance(new_future.exception(), RuntimeError)
+    new_future0 = future0.catch(_crash)
+    assert isinstance(new_future0.exception(), RuntimeError)
 
-    future = UnifiedFuture.from_call(succeeds)
-    new_future = future.catch(lambda v: str(v))
+    future1 = UnifiedFuture.from_call(succeeds)
+    new_future1 = future1.catch(lambda v: str(v))
     # Result is 1 because the future succeeded (no exception to catch)
-    result = new_future.result()
+    result = new_future1.result()
     assert result == 1
 
 
@@ -684,3 +684,60 @@ def test_run_as_completed_next_cycle_fails_async() -> None:
         assert isinstance(state.exception(), ValueError)
     finally:
         set_loop(NO_LOOP)
+
+
+def test_unified_future_cancellation_propagation() -> None:
+    raw = UnifiedFuture[int]()
+    mapped = raw.map(lambda x: x * 2)
+    chained = mapped.map(lambda x: x + 1)
+
+    assert chained.cancel() is True
+    assert chained.cancelled() is True
+    assert mapped.cancelled() is True
+    assert raw.cancelled() is True
+
+
+def test_unified_future_child_cancelled_parent_resolves() -> None:
+    raw = UnifiedFuture[int]()
+    mapped = raw.map(lambda x: x * 2, cancel_cb=lambda: None)
+    chained = mapped.map(lambda x: x + 1)
+
+    assert chained.cancel() is True
+    assert chained.cancelled() is True
+    assert mapped.cancelled() is True
+    assert raw.cancelled() is False
+
+    # Resolving raw future whose downstream child was cancelled should not raise InvalidStateError in callbacks
+    raw.set_result(10)
+    assert raw.result() == 10
+
+
+def test_unified_future_custom_on_cancel() -> None:
+    cancelled_calls = list[str]()
+    raw = UnifiedFuture[int]()
+    mapped = raw.map(lambda x: x * 2, cancel_cb=lambda: cancelled_calls.append("custom_cancel"))
+
+    assert mapped.cancel() is True
+    assert mapped.cancelled() is True
+    assert cancelled_calls == ["custom_cancel"]
+    # Parent raw future was not cancelled because custom on_cancel intercepted it
+    assert raw.cancelled() is False
+
+
+def test_unified_future_parent_cancelled() -> None:
+    raw = UnifiedFuture[int]()
+    mapped = raw.map(lambda x: x * 2)
+    caught = raw.catch(lambda _: 0)
+
+    raw.cancel()
+    assert mapped.cancelled() is True
+    assert caught.cancelled() is True
+
+
+def test_unified_future_from_future_cancellation() -> None:
+    raw = Future[int]()
+    uni = UnifiedFuture.from_future(raw)
+
+    assert uni.cancel() is True
+    assert uni.cancelled() is True
+    assert raw.cancelled() is True

vsjetengine-1.6.2/vsengine/_version.py

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

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

@@ -78,12 +78,16 @@ class UnifiedFuture[T](Future[T], AbstractContextManager[Any], AbstractAsyncCont
         result = cls()
 
         def _receive(fn: Future[S]) -> None:
+            if future.cancelled():
+                result.cancel()
+                return
             if (exc := future.exception()) is not None:
                 result.set_exception(exc)
-            else:
+            elif not result.cancelled():
                 result.set_result(future.result())
 
         future.add_done_callback(_receive)
+        result.add_done_callback(lambda f: future.cancel() if f.cancelled() else None)
         return result
 
     @classmethod
@@ -154,18 +158,45 @@ class UnifiedFuture[T](Future[T], AbstractContextManager[Any], AbstractAsyncCont
 
     # Manipulating futures
     @overload
-    def then[S](self, success_cb: Callable[[T], S], *, on_loop: bool = ...) -> UnifiedFuture[S]: ...
+    def then[S](
+        self,
+        success_cb: Callable[[T], S],
+        *,
+        cancel_cb: Callable[[], None] | None = ...,
+        on_loop: bool = ...,
+    ) -> UnifiedFuture[S]: ...
     @overload
-    def then[S](self, success_cb: Callable[[T], S], err_cb: None = ..., *, on_loop: bool = ...) -> UnifiedFuture[S]: ...
+    def then[S](
+        self,
+        success_cb: Callable[[T], S],
+        err_cb: None = ...,
+        cancel_cb: Callable[[], None] | None = ...,
+        *,
+        on_loop: bool = ...,
+    ) -> UnifiedFuture[S]: ...
     @overload
-    def then[V](self, success_cb: None, err_cb: Callable[[BaseException], V], *, on_loop: bool = ...) -> UnifiedFuture[T | V]: ...  # fmt: skip  # noqa: E501
+    def then[V](
+        self,
+        success_cb: None,
+        err_cb: Callable[[BaseException], V],
+        cancel_cb: Callable[[], None] | None = ...,
+        *,
+        on_loop: bool = ...,
+    ) -> UnifiedFuture[T | V]: ...
     @overload
-    def then[V](self, *, err_cb: Callable[[BaseException], V], on_loop: bool = ...) -> UnifiedFuture[T | V]: ...
+    def then[V](
+        self,
+        *,
+        err_cb: Callable[[BaseException], V],
+        cancel_cb: Callable[[], None] | None = ...,
+        on_loop: bool = ...,
+    ) -> UnifiedFuture[T | V]: ...
     @overload
     def then[S, V](
         self,
         success_cb: Callable[[T], S],
         err_cb: Callable[[BaseException], V],
+        cancel_cb: Callable[[], None] | None = ...,
         *,
         on_loop: bool = ...,
     ) -> UnifiedFuture[S | V]: ...
@@ -173,6 +204,7 @@ class UnifiedFuture[T](Future[T], AbstractContextManager[Any], AbstractAsyncCont
         self,
         success_cb: Callable[[T], S] | None = None,
         err_cb: Callable[[BaseException], V] | None = None,
+        cancel_cb: Callable[[], None] | None = None,
         *,
         on_loop: bool = False,
     ) -> Any:
@@ -188,17 +220,25 @@ 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 cancel_cb: Optional callback invoked when the returned future is cancelled.
+            Defaults to cancelling the parent future.
         :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:
+            if result.cancelled():
+                return
             if on_loop:
                 loop_fut = get_loop().from_thread(cb, v)
 
                 def _forward(lf: Future[Any]) -> None:
-                    if (exc := lf.exception()) is not 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())
@@ -213,39 +253,60 @@ class UnifiedFuture[T](Future[T], AbstractContextManager[Any], AbstractAsyncCont
                     result.set_result(r)
 
         def _done(fn: 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)
                 else:
                     result.set_exception(exc)
-            else:
+            elif not result.cancelled():
                 if success_cb is not None:
                     _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)
         return result
 
-    def map[V](self, cb: Callable[[T], V], *, on_loop: bool = False) -> UnifiedFuture[V]:
+    def map[V](
+        self,
+        cb: Callable[[T], V],
+        cancel_cb: Callable[[], None] | None = None,
+        *,
+        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 cancel_cb: Optional callback invoked when the returned future is cancelled.
         :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, on_loop=on_loop)
+        return self.then(cb, None, cancel_cb, on_loop=on_loop)
 
-    def catch[V](self, cb: Callable[[BaseException], V], *, on_loop: bool = False) -> UnifiedFuture[T | V]:
+    def catch[V](
+        self,
+        cb: Callable[[BaseException], V],
+        cancel_cb: Callable[[], None] | None = None,
+        *,
+        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 cancel_cb: Optional callback invoked when the returned future is cancelled.
         :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, on_loop=on_loop)
+        return self.then(None, cb, cancel_cb, on_loop=on_loop)
 
     # Nicer Syntax
     def __enter__[EnterT](self: FutureLike[AbstractContextManager[EnterT, Any]]) -> EnterT:

{vsjetengine-1.6.0 → vsjetengine-1.6.2}/vsengine/vpy.py

@@ -11,9 +11,11 @@ import ast
 import io
 import os
 import sys
+import textwrap
+import traceback
 from collections.abc import Awaitable, Buffer, Callable, Generator
 from concurrent.futures import Future
-from contextlib import AbstractContextManager, suppress
+from contextlib import AbstractContextManager, nullcontext, suppress
 from types import CodeType, ModuleType, TracebackType
 from typing import Any, Concatenate, Self, overload
 from uuid import uuid4
@@ -44,8 +46,6 @@ class ExecutionError(Exception):
 
         :param parent_error: The original exception that occurred.
         """
-        import textwrap
-
         msg = textwrap.indent(self.extract_traceback(parent_error), "| ")
         super().__init__(f"An exception was raised while running the script.\n{msg}")
         self.parent_error = parent_error
@@ -58,11 +58,7 @@ class ExecutionError(Exception):
         :param error: The exception to extract the traceback from.
         :return: A formatted string containing the traceback.
         """
-        import traceback
-
-        msg = traceback.format_exception(type(error), error, error.__traceback__)
-        msg = "".join(msg)
-        return msg
+        return "".join(traceback.format_exception(type(error), error, error.__traceback__))
 
 
 class WrapAllErrors(AbstractContextManager[None]):
@@ -455,8 +451,8 @@ def load_code(
         with (
             ctx,
             _TempModule(module.__name__, module),
-            _ModifiedPath(path) if path else ctx,
-            _ModifiedArgv0(filename) if path else ctx,
+            _ModifiedPath(path) if path else nullcontext(),
+            _ModifiedArgv0(filename) if path else nullcontext(),
         ):
             code = (
                 compile(script, **{"filename": filename, "dont_inherit": True, "flags": 0, "mode": "exec"} | kwargs)

vsjetengine-1.6.0/vsengine/_version.py

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