vsjetengine 1.2.0__tar.gz → 1.3.0__tar.gz

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

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

@@ -7,14 +7,14 @@
 
 import contextlib
 import threading
-from collections.abc import AsyncIterator, Iterator
+from collections.abc import AsyncGenerator, Generator, Iterator
 from concurrent.futures import Future
 from typing import Any
 
 import pytest
 
-from vsengine._futures import UnifiedFuture, UnifiedIterator, unified
 from vsengine.adapters.asyncio import AsyncIOLoop
+from vsengine.futures import UnifiedFuture, UnifiedIterator, unified
 from vsengine.loops import NO_LOOP, set_loop
 
 
@@ -32,7 +32,7 @@ def reject(err: BaseException) -> Future[Any]:
 
 def contextmanager_helper() -> Future[Any]:
     @contextlib.contextmanager
-    def noop() -> Iterator[int]:
+    def noop() -> Generator[int]:
         yield 1
 
     return resolve(noop())
@@ -40,7 +40,7 @@ def contextmanager_helper() -> Future[Any]:
 
 def asynccontextmanager_helper() -> Future[Any]:
     @contextlib.asynccontextmanager
-    async def noop() -> AsyncIterator[int]:
+    async def noop() -> AsyncGenerator[int]:
         yield 2
 
     return resolve(noop())

{vsjetengine-1.2.0 → vsjetengine-1.3.0}/tests/test_hospice.py

@@ -9,7 +9,7 @@ import contextlib
 import gc
 import logging
 import weakref
-from collections.abc import Iterator
+from collections.abc import Generator, Iterator
 from typing import Any
 
 import pytest
@@ -53,7 +53,7 @@ class MockEnv:
 
 
 @contextlib.contextmanager
-def hide_logs() -> Iterator[None]:
+def hide_logs() -> Generator[None]:
     logging.disable(logging.CRITICAL)
     try:
         yield

{vsjetengine-1.2.0 → vsjetengine-1.3.0}/tests/test_loop_adapters.py

@@ -42,7 +42,7 @@ class AdapterTest:
     """Base class for event loop adapter tests."""
 
     @contextlib.contextmanager
-    def with_loop(self) -> Iterator[EventLoop]:
+    def with_loop(self) -> Generator[EventLoop]:
         loop = self.make_loop()
         set_loop(loop)
         try:
@@ -60,7 +60,7 @@ class AdapterTest:
         raise NotImplementedError
 
     @contextlib.contextmanager
-    def assert_cancelled(self) -> Iterator[None]:
+    def assert_cancelled(self) -> Generator[None]:
         raise NotImplementedError
 
     @make_async
@@ -216,7 +216,7 @@ class TestNoLoop(AdapterTest):
                 pass
 
     @contextlib.contextmanager
-    def assert_cancelled(self) -> Iterator[None]:
+    def assert_cancelled(self) -> Generator[None]:
         with pytest.raises(CancelledError):
             yield
 
@@ -244,7 +244,7 @@ class TestAsyncIO(AsyncAdapterTest):
         return await asyncio.wait_for(coro, timeout)
 
     @contextlib.contextmanager
-    def assert_cancelled(self) -> Iterator[None]:
+    def assert_cancelled(self) -> Generator[None]:
         with pytest.raises(asyncio.CancelledError):
             yield
 
@@ -309,6 +309,6 @@ else:
                 return await coro
 
         @contextlib.contextmanager
-        def assert_cancelled(self) -> Iterator[None]:
+        def assert_cancelled(self) -> Generator[None]:
             with pytest.raises(trio.Cancelled):
                 yield

{vsjetengine-1.2.0 → vsjetengine-1.3.0}/tests/test_vpy.py

@@ -15,7 +15,7 @@ import textwrap
 import threading
 import types
 import weakref
-from collections.abc import Callable, Iterator
+from collections.abc import Callable, Generator
 from pathlib import Path
 from typing import Any
 
@@ -44,7 +44,7 @@ PATH: str = os.path.join(DIR, "fixtures", "test.vpy")
 
 
 @contextlib.contextmanager
-def noop() -> Iterator[None]:
+def noop() -> Generator[None]:
     yield
 
 

{vsjetengine-1.2.0 → vsjetengine-1.3.0}/vsengine/__init__.py

@@ -13,6 +13,7 @@ Parts:
 - vpy:     Run .vpy-scripts in your application.
 """
 
+from vsengine.futures import *
 from vsengine.loops import *
 from vsengine.policy import *
 from vsengine.video import *

{vsjetengine-1.2.0 → vsjetengine-1.3.0}/vsengine/_helpers.py

@@ -4,7 +4,7 @@
 # This project is licensed under the EUPL-1.2
 # SPDX-License-Identifier: EUPL-1.2
 import contextlib
-from collections.abc import Iterator
+from collections.abc import Generator
 
 import vapoursynth as vs
 
@@ -13,7 +13,7 @@ from vsengine.policy import ManagedEnvironment
 
 # Automatically set the environment within that block.
 @contextlib.contextmanager
-def use_inline(function_name: str, env: vs.Environment | ManagedEnvironment | None) -> Iterator[None]:
+def use_inline(function_name: str, env: vs.Environment | ManagedEnvironment | None) -> Generator[None]:
     if env is None:
         # Ensure there is actually an environment set in this block.
         try:

vsjetengine-1.3.0/vsengine/_version.py

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

{vsjetengine-1.2.0 → vsjetengine-1.3.0}/vsengine/adapters/asyncio.py

@@ -7,7 +7,7 @@
 import asyncio
 import contextlib
 import contextvars
-from collections.abc import Callable, Iterator
+from collections.abc import Callable, Generator
 from concurrent.futures import Future
 
 from vsengine.loops import Cancelled, EventLoop
@@ -78,7 +78,7 @@ class AsyncIOLoop(EventLoop):
             return await asyncio.wrap_future(future, loop=self.loop)
 
     @contextlib.contextmanager
-    def wrap_cancelled(self) -> Iterator[None]:
+    def wrap_cancelled(self) -> Generator[None]:
         try:
             yield
         except Cancelled:

{vsjetengine-1.2.0 → vsjetengine-1.3.0}/vsengine/adapters/trio.py

@@ -5,7 +5,7 @@
 # SPDX-License-Identifier: EUPL-1.2
 
 import contextlib
-from collections.abc import Callable, Iterator
+from collections.abc import Callable, Generator
 from concurrent.futures import Future
 
 import trio
@@ -100,7 +100,7 @@ class TrioEventLoop(EventLoop):
                 raise exc
 
     @contextlib.contextmanager
-    def wrap_cancelled(self) -> Iterator[None]:
+    def wrap_cancelled(self) -> Generator[None]:
         try:
             yield
         except Cancelled:

vsjetengine-1.2.0/vsengine/_futures.py → vsjetengine-1.3.0/vsengine/futures.py

@@ -5,20 +5,47 @@
 # SPDX-License-Identifier: EUPL-1.2
 from __future__ import annotations
 
+import traceback
 from collections.abc import AsyncIterator, Awaitable, Callable, Generator, Iterator
 from concurrent.futures import Future
 from contextlib import AbstractAsyncContextManager, AbstractContextManager
 from functools import wraps
 from inspect import isgeneratorfunction
 from types import TracebackType
-from typing import Any, Literal, Self, overload
+from typing import Any, Literal, Protocol, Self, overload
 
-from vsengine.loops import Cancelled, get_loop, keep_environment
+from vsengine.loops import get_loop, keep_environment
 
+__all__ = ["UnifiedFuture", "UnifiedIterator", "unified"]
+
+
+class FutureLike[V](Protocol):
+    def result(self) -> V: ...
+
+
+class AsyncFutureLike[V](Protocol):
+    async def awaitable(self) -> V: ...
+
+
+class UnifiedFuture[T](Future[T], AbstractContextManager[Any], AbstractAsyncContextManager[Any], Awaitable[T]):
+    """
+    A Promise-inspired Future that unifies concurrent.futures.Future
+    with Python's synchronous and asynchronous context manager and awaitable protocols.
+    """
 
-class UnifiedFuture[T](Future[T], AbstractContextManager[T, Any], AbstractAsyncContextManager[T, Any], Awaitable[T]):
     @classmethod
     def from_call[**P](cls, func: Callable[P, Future[T]], *args: P.args, **kwargs: P.kwargs) -> Self:
+        """
+        Call `func` and wrap the returned `Future` as a `UnifiedFuture`.
+
+        Any exception raised synchronously by `func` is captured and stored as a rejection
+        on the returned future rather than propagating to the caller.
+
+        :param func: A callable that returns a `Future`.
+        :param args: Positional arguments forwarded to `func`.
+        :param kwargs: Keyword arguments forwarded to `func`.
+        :return: A `UnifiedFuture` that mirrors the result of `func`.
+        """
         try:
             future = func(*args, **kwargs)
         except Exception as e:
@@ -28,6 +55,14 @@ class UnifiedFuture[T](Future[T], AbstractContextManager[T, Any], AbstractAsyncC
 
     @classmethod
     def from_future(cls, future: Future[T]) -> Self:
+        """
+        Wrap an existing `Future` as a `UnifiedFuture`.
+
+        If `future` is already an instance of this class it is returned unchanged.
+
+        :param future: The future to wrap.
+        :return: A `UnifiedFuture` that mirrors `future`.
+        """
         if isinstance(future, cls):
             return future
 
@@ -44,22 +79,51 @@ class UnifiedFuture[T](Future[T], AbstractContextManager[T, Any], AbstractAsyncC
 
     @classmethod
     def resolve(cls, value: T) -> Self:
+        """
+        Return an already-resolved `UnifiedFuture` carrying `value`.
+
+        :param value: The value to resolve with.
+        :return: A resolved `UnifiedFuture`.
+        """
         future = cls()
         future.set_result(value)
         return future
 
     @classmethod
     def reject(cls, error: BaseException) -> Self:
+        """
+        Return an already-rejected `UnifiedFuture` carrying `error`.
+
+        :param error: The exception to reject with.
+        :return: A rejected `UnifiedFuture`.
+        """
         future = cls()
         future.set_exception(error)
         return future
 
     # Adding callbacks
     def add_done_callback(self, fn: Callable[[Future[T]], Any]) -> None:
+        """
+        Register a callback to be called when this future completes.
+
+        Wraps the callback in `keep_environment` so that the VapourSynth environment active at registration time
+        is restored when the callback fires (potentially from a worker thread).
+
+        :param fn: A callable that receives the completed future.
+        """
         # 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]], None]) -> None:
+    def add_loop_callback(self, func: Callable[[Future[T]], Any]) -> None:
+        """
+        Register a callback that is guaranteed to run on the event-loop thread.
+
+        Unlike `add_done_callback`, which may fire from any thread,
+        this method marshals `func` back to the main event loop via `EventLoop.from_thread`.
+
+        :param func: A callable that receives the completed future.
+        """
+
         def _wrapper(future: Future[T]) -> None:
             get_loop().from_thread(func, future)
 
@@ -67,18 +131,36 @@ class UnifiedFuture[T](Future[T], AbstractContextManager[T, Any], AbstractAsyncC
 
     # Manipulating futures
     @overload
-    def then[V](self, success_cb: Callable[[T], V], err_cb: None) -> UnifiedFuture[V]: ...
+    def then[S](self, success_cb: Callable[[T], S]) -> UnifiedFuture[S]: ...
+    @overload
+    def then[S](self, success_cb: Callable[[T], S], err_cb: None = ...) -> UnifiedFuture[S]: ...
     @overload
     def then[V](self, success_cb: None, err_cb: Callable[[BaseException], V]) -> UnifiedFuture[T | V]: ...
-    def then[V](
-        self, success_cb: Callable[[T], V] | None, err_cb: Callable[[BaseException], V] | None
-    ) -> UnifiedFuture[V] | UnifiedFuture[T | V]:
-        result = UnifiedFuture[T | V]()
+    @overload
+    def then[V](self, *, err_cb: Callable[[BaseException], V]) -> 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
+        """
+        Attach fulfilment and/or rejection handlers, returning a new future.
+
+        * If this future resolves successfully, `success_cb` is called with the result value.
+          If `success_cb` is `None` the result is forwarded as-is.
+        * If this future is rejected, `err_cb` is called with the exception.
+          If `err_cb` is `None` the exception is forwarded as-is.
+
+        Exceptions raised inside either callback are captured and stored as rejections on the returned future.
+
+        :param success_cb: Called with the resolved value, or `None` to passthrough.
+        :param err_cb: Called with the exception, or `None` to passthrough.
+        :return: A new `UnifiedFuture` carrying the callback's return value.
+        """
+        result = UnifiedFuture[Any]()
 
-        def _run_cb(cb: Callable[[Any], V], v: Any) -> None:
+        def _run_cb(cb: Callable[[Any], Any], v: T | BaseException) -> None:
             try:
                 r = cb(v)
-            except BaseException as e:
+            except Exception as e:
                 result.set_exception(e)
             else:
                 result.set_result(r)
@@ -99,13 +181,25 @@ class UnifiedFuture[T](Future[T], AbstractContextManager[T, Any], AbstractAsyncC
         return result
 
     def map[V](self, cb: Callable[[T], V]) -> UnifiedFuture[V]:
+        """
+        Transform the resolved value with `cb`, returning a new future.
+
+        :param cb: A callable that transforms the resolved value.
+        :return: A new `UnifiedFuture` carrying the transformed value.
+        """
         return self.then(cb, None)
 
     def catch[V](self, cb: Callable[[BaseException], V]) -> 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.
+        :return: A new `UnifiedFuture` carrying the recovery value on error, or the original resolved value on success.
+        """
         return self.then(None, cb)
 
     # Nicer Syntax
-    def __enter__(self) -> T:
+    def __enter__[EnterT](self: FutureLike[AbstractContextManager[EnterT, Any]]) -> EnterT:
         obj = self.result()
 
         if isinstance(obj, AbstractContextManager):
@@ -113,7 +207,12 @@ class UnifiedFuture[T](Future[T], AbstractContextManager[T, Any], AbstractAsyncC
 
         raise NotImplementedError("(async) with is not implemented for this object")
 
-    def __exit__(self, exc: type[BaseException] | None, val: BaseException | None, tb: TracebackType | None) -> None:
+    def __exit__(
+        self,
+        exc: type[BaseException] | None,
+        val: BaseException | None,
+        tb: TracebackType | None,
+    ) -> bool | None:
         obj = self.result()
 
         if isinstance(obj, AbstractContextManager):
@@ -122,12 +221,20 @@ class UnifiedFuture[T](Future[T], AbstractContextManager[T, Any], AbstractAsyncC
         raise NotImplementedError("(async) with is not implemented for this object")
 
     async def awaitable(self) -> T:
+        """
+        Await this future using the currently active event loop.
+
+        :return: The resolved value of this future.
+        :raises: Whatever exception this future was rejected with.
+        """
         return await get_loop().await_future(self)
 
     def __await__(self) -> Generator[Any, None, T]:
         return self.awaitable().__await__()
 
-    async def __aenter__(self) -> T:
+    async def __aenter__[EnterT](
+        self: AsyncFutureLike[AbstractAsyncContextManager[EnterT, Any] | AbstractContextManager[EnterT, Any]],
+    ) -> EnterT:
         result = await self.awaitable()
 
         if isinstance(result, AbstractAsyncContextManager):
@@ -138,8 +245,11 @@ class UnifiedFuture[T](Future[T], AbstractContextManager[T, Any], AbstractAsyncC
         raise NotImplementedError("(async) with is not implemented for this object")
 
     async def __aexit__(
-        self, exc: type[BaseException] | None, val: BaseException | None, tb: TracebackType | None
-    ) -> None:
+        self,
+        exc: type[BaseException] | None,
+        val: BaseException | None,
+        tb: TracebackType | None,
+    ) -> bool | None:
         result = await self.awaitable()
 
         if isinstance(result, AbstractAsyncContextManager):
@@ -151,30 +261,61 @@ class UnifiedFuture[T](Future[T], AbstractContextManager[T, Any], AbstractAsyncC
 
 
 class UnifiedIterator[T](Iterator[T], AsyncIterator[T]):
+    """
+    A dual-mode iterator that wraps an `Iterator[Future[T]]`
+    and exposes it as both a synchronous `Iterator` and an asynchronous `AsyncIterator`.
+
+    In synchronous mode (`__next__`), each future is resolved by calling `Future.result()`.
+    This blocks if the future is not yet done.
+
+    In asynchronous mode (`__anext__`), each future is awaited via `EventLoop.await_future`,
+    cooperating with the active event loop.
+    """
+
     def __init__(self, future_iterable: Iterator[Future[T]]) -> None:
         self.future_iterable = future_iterable
 
     @classmethod
     def from_call[**P](cls, func: Callable[P, Iterator[Future[T]]], *args: P.args, **kwargs: P.kwargs) -> Self:
+        """
+        Call `func` and wrap the returned iterator as a `UnifiedIterator`.
+
+        :param func: A callable that returns an `Iterator[Future[T]]`.
+        :param args: Positional arguments forwarded to `func`.
+        :param kwargs: Keyword arguments forwarded to `func`.
+        :return: A `UnifiedIterator` wrapping the returned iterator.
+        """
         return cls(func(*args, **kwargs))
 
     @property
     def futures(self) -> Iterator[Future[T]]:
+        """The raw underlying `Iterator[Future[T]]`."""
         return self.future_iterable
 
     def run_as_completed(self, callback: Callable[[Future[T]], Any]) -> UnifiedFuture[None]:
-        state = UnifiedFuture[None]()
+        """
+        Consume the iterator and invoke `callback` for each future as it completes.
 
-        def _is_done_or_cancelled() -> bool:
-            if state.done():
-                return True
-            if state.cancelled():
-                state.set_exception(Cancelled())
-                return True
-            return False
+        The loop is event-loop-cooperative:
+        after each callback it calls `EventLoop.next_cycle` to yield control back to the event loop
+        so that other work can proceed.
+
+        The returned `UnifiedFuture` resolves to `None` when all futures have been processed, or is rejected if:
+
+        * the iterator raises,
+        * `callback` raises, or
+        * `callback` returns a falsy non-`None` value (signals an early stop).
+
+        Cancellation is detected by checking `Future.cancelled()` on the state future; raise `Cancelled` to abort.
+
+        :param callback: Called for each completed `Future`.
+            Return `None` or a truthy value to continue; return a falsy value to stop iteration early.
+        :return: A `UnifiedFuture` that resolves when iteration is complete.
+        """
+        state = UnifiedFuture[None]()
 
         def _get_next_future() -> Future[T] | None:
-            if _is_done_or_cancelled():
+            if state.done():
                 return None
 
             try:
@@ -211,8 +352,6 @@ class UnifiedIterator[T](Iterator[T], AsyncIterator[T]):
                         state.set_exception(next_cycle.exception())
                         return
             except Exception as e:
-                import traceback
-
                 traceback.print_exception(e)
                 state.set_exception(e)
 
@@ -234,12 +373,12 @@ class UnifiedIterator[T](Iterator[T], AsyncIterator[T]):
         def _run_single_callback(fut: Future[T]) -> bool:
             # True   => Schedule next future.
             # False  => Cancel the loop.
-            if _is_done_or_cancelled():
+            if state.done():
                 return False
 
             try:
                 result = callback(fut)
-            except BaseException as e:
+            except Exception as e:
                 state.set_exception(e)
                 return False
             else:
@@ -335,8 +474,38 @@ def unified[T, **P](
     future_class: type[UnifiedFuture[Any]] = UnifiedFuture[Any],
 ) -> Any:
     """
-    Decorator to normalize functions returning Future[T] or Iterator[Future[T]]
-    into functions returning UnifiedFuture[T] or UnifiedIterator[T].
+    Decorator factory to normalize functions that return raw futures or iterators of futures
+    into functions that return `UnifiedFuture` or `UnifiedIterator`.
+
+    :param kind: Controls which wrapper is applied.
+
+        `"auto"` (default)
+            Automatically detects generator functions (via `isgeneratorfunction`)
+            and wraps them as `UnifiedIterator`; all other callables are wrapped as
+            `UnifiedFuture`.
+
+        `"future"`
+            Always wrap as `UnifiedFuture`.
+
+        `"generator"`
+            Always wrap as `UnifiedIterator`.
+
+    :param future_class: The concrete `UnifiedFuture` subclass to use when wrapping single-value futures.
+    :param iterable_class: The concrete `UnifiedIterator` subclass to use when wrapping generators.
+    :return: A decorator that wraps the target function.
+
+    Example usage:
+    ```python
+    @unified(kind="future")
+    def request_frame(index: int) -> Future[vs.VideoFrame]:
+        return node.get_frame_async(index)
+
+
+    @unified(kind="generator")
+    def request_all_frames(node: vs.VideoNode) -> Iterator[Future[vs.VideoFrame]]:
+        for i in range(node.num_frames):
+            yield node.get_frame_async(i)
+    ```
     """
 
     def _decorator_generator(func: Callable[P, Iterator[Future[T]]]) -> Callable[P, UnifiedIterator[T]]:

{vsjetengine-1.2.0 → vsjetengine-1.3.0}/vsengine/loops.py

@@ -8,7 +8,7 @@
 
 import threading
 from abc import abstractmethod
-from collections.abc import Awaitable, Callable, Iterator
+from collections.abc import Awaitable, Callable, Generator
 from concurrent.futures import CancelledError, Future
 from contextlib import contextmanager
 from functools import wraps
@@ -23,7 +23,7 @@ class Cancelled(BaseException):
 
 
 @contextmanager
-def _noop() -> Iterator[None]:
+def _noop() -> Generator[None]:
     yield
 
 
@@ -126,7 +126,7 @@ class EventLoop:
         raise NotImplementedError
 
     @contextmanager
-    def wrap_cancelled(self) -> Iterator[None]:
+    def wrap_cancelled(self) -> Generator[None]:
         """
         Context manager to translate cancellation exceptions.
 

{vsjetengine-1.2.0 → vsjetengine-1.3.0}/vsengine/policy.py

@@ -12,7 +12,7 @@ from __future__ import annotations
 
 import threading
 from abc import ABC, abstractmethod
-from collections.abc import Iterator
+from collections.abc import Generator
 from contextlib import AbstractContextManager, contextmanager
 from contextvars import ContextVar
 from logging import getLogger
@@ -272,7 +272,7 @@ class ManagedEnvironment(AbstractContextManager["ManagedEnvironment"]):
         del self._data
 
     @contextmanager
-    def inline_section(self) -> Iterator[None]:
+    def inline_section(self) -> Generator[None]:
         """
         Private API!
 
@@ -295,7 +295,7 @@ class ManagedEnvironment(AbstractContextManager["ManagedEnvironment"]):
             self._policy.managed.inline_section_end()
 
     @contextmanager
-    def use(self) -> Iterator[None]:
+    def use(self) -> Generator[None]:
         """
         Switches to this environment within a block.
         """
@@ -328,16 +328,16 @@ class Policy(AbstractContextManager["Policy"]):
 
     _managed: _ManagedPolicy
 
-    def __init__(self, store: EnvironmentStore, flags_creation: int = 0) -> None:
+    def __init__(self, store: EnvironmentStore | None = None, flags_creation: int = 0) -> None:
         """
         Initializes a new Policy
 
         Args:
-            store: The store to use for managing environments.
+            store: The store to use for managing environments. If None, defaults to a GlobalStore.
             flags_creation: The flags to use when creating environments.
                             See vapoursynth.CoreCreationFlags for more information.
         """
-        self._managed = _ManagedPolicy(store)
+        self._managed = _ManagedPolicy(store or GlobalStore())
         self.flags_creation = flags_creation
 
     def __enter__(self) -> Self:

{vsjetengine-1.2.0 → vsjetengine-1.3.0}/vsengine/video.py

@@ -12,9 +12,9 @@ from concurrent.futures import Future
 
 import vapoursynth as vs
 
-from ._futures import UnifiedFuture, unified
 from ._helpers import use_inline
 from ._nodes import buffer_futures, close_when_needed
+from .futures import UnifiedFuture, unified
 from .policy import ManagedEnvironment
 
 __all__ = ["frame", "frames", "planes", "render"]

{vsjetengine-1.2.0 → vsjetengine-1.3.0}/vsengine/vpy.py

@@ -20,7 +20,7 @@ from uuid import uuid4
 
 import vapoursynth as vs
 
-from ._futures import UnifiedFuture, unified
+from .futures import UnifiedFuture, unified
 from .loops import make_awaitable, to_thread
 from .policy import ManagedEnvironment, Policy
 

vsjetengine-1.2.0/vsengine/_version.py

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