vsjetengine 1.0.0__tar.gz → 1.2.0__tar.gz

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

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: vsjetengine
-Version: 1.0.0
+Version: 1.2.0
 Summary: An engine for vapoursynth previewers, renderers and script analyis tools.
-Project-URL: Source Code, https://github.com/Jaded-Encoding-Thaumaturgy/vs-engine
+Project-URL: Source Code, https://github.com/Jaded-Encoding-Thaumaturgy/vs-jet-engine
 Project-URL: Contact, https://discord.gg/XTpc6Fa9eB
 Author-email: cid-chan <cid+git@cid-chan.moe>
 Maintainer-email: Vardë <ichunjo.le.terrible@gmail.com>, Jaded Encoding Thaumaturgy <jaded.encoding.thaumaturgy@gmail.com>
@@ -317,7 +317,7 @@ Description-Content-Type: text/markdown
 [![Tests](https://github.com/Jaded-Encoding-Thaumaturgy/vs-engine/actions/workflows/test.yml/badge.svg)](https://github.com/Jaded-Encoding-Thaumaturgy/vs-engine/actions/workflows/test.yml)
 [![Coverage Status](https://coveralls.io/repos/github/Jaded-Encoding-Thaumaturgy/vs-engine/badge.svg?branch=main)](https://coveralls.io/github/Jaded-Encoding-Thaumaturgy/vs-engine?branch=main)
 
-An engine for vapoursynth previewers, renderers and script analyis tools.
+An engine for vapoursynth previewers, renderers and script analysis tools.
 
 ## Installation
 

{vsjetengine-1.0.0 → vsjetengine-1.2.0}/README.md

@@ -4,7 +4,7 @@
 [![Tests](https://github.com/Jaded-Encoding-Thaumaturgy/vs-engine/actions/workflows/test.yml/badge.svg)](https://github.com/Jaded-Encoding-Thaumaturgy/vs-engine/actions/workflows/test.yml)
 [![Coverage Status](https://coveralls.io/repos/github/Jaded-Encoding-Thaumaturgy/vs-engine/badge.svg?branch=main)](https://coveralls.io/github/Jaded-Encoding-Thaumaturgy/vs-engine?branch=main)
 
-An engine for vapoursynth previewers, renderers and script analyis tools.
+An engine for vapoursynth previewers, renderers and script analysis tools.
 
 ## Installation
 

{vsjetengine-1.0.0 → vsjetengine-1.2.0}/pyproject.toml

@@ -30,7 +30,7 @@ dependencies = ["vapoursynth>=69"]
 dynamic = ["version"]
 
 [project.urls]
-"Source Code" = "https://github.com/Jaded-Encoding-Thaumaturgy/vs-engine"
+"Source Code" = "https://github.com/Jaded-Encoding-Thaumaturgy/vs-jet-engine"
 "Contact" = "https://discord.gg/XTpc6Fa9eB"
 
 [project.optional-dependencies]

{vsjetengine-1.0.0 → vsjetengine-1.2.0}/tests/_testutils.py

@@ -94,17 +94,17 @@ class ProxyPolicy(EnvironmentPolicy):
 
     def get_current_environment(self) -> EnvironmentData | None:
         if self._policy is None:
-            raise RuntimeError("This proxy is not attached to a policy.")
+            return None
         return self._policy.get_current_environment()
 
     def set_environment(self, environment: EnvironmentData | None) -> EnvironmentData | None:
         if self._policy is None:
-            raise RuntimeError("This proxy is not attached to a policy.")
+            return None
         return self._policy.set_environment(environment)
 
     def is_alive(self, environment: EnvironmentData) -> bool:
         if self._policy is None:
-            raise RuntimeError("This proxy is not attached to a policy.")
+            return False
         return self._policy.is_alive(environment)
 
 
@@ -123,6 +123,7 @@ class StandalonePolicy(EnvironmentPolicy):
 
     def on_policy_cleared(self) -> None:
         admit_environment(self._current, self._core)
+        self._api.destroy_environment(self._current)
 
         del self._current
         del self._core

{vsjetengine-1.0.0 → vsjetengine-1.2.0}/tests/conftest.py

@@ -12,6 +12,7 @@ from collections.abc import Iterator
 import pytest
 
 from tests._testutils import forcefully_unregister_policy
+from vsengine import _hospice
 from vsengine.loops import NO_LOOP, set_loop
 
 
@@ -29,3 +30,21 @@ def clean_policy() -> Iterator[None]:
     yield
     forcefully_unregister_policy()
     set_loop(NO_LOOP)
+
+
+@pytest.fixture(autouse=True)
+def reset_hospice_state() -> Iterator[None]:
+    """Reset hospice module state before each test to ensure isolation."""
+    _hospice.stage1.clear()
+    _hospice.stage2.clear()
+    _hospice.stage2_to_add.clear()
+    _hospice.hold.clear()
+    _hospice.cores.clear()
+    _hospice.refnanny.clear()
+    yield
+    _hospice.stage1.clear()
+    _hospice.stage2.clear()
+    _hospice.stage2_to_add.clear()
+    _hospice.hold.clear()
+    _hospice.cores.clear()
+    _hospice.refnanny.clear()

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

@@ -14,31 +14,15 @@ from typing import Any
 
 import pytest
 
-from vsengine import _hospice
 from vsengine._hospice import admit_environment, any_alive, freeze, unfreeze
 
 
 @pytest.fixture(autouse=True)
-def reset_hospice_state() -> Iterator[None]:
-    """Reset hospice module state before each test to ensure isolation."""
-    # Clear the mock timings registry
+def reset_mock_registry() -> Iterator[None]:
+    """Reset the mock timings registry before each test."""
     _mock_timings_registry.clear()
-    # Clear all hospice state before test
-    _hospice.stage1.clear()
-    _hospice.stage2.clear()
-    _hospice.stage2_to_add.clear()
-    _hospice.hold.clear()
-    _hospice.cores.clear()
-    _hospice.refnanny.clear()
     yield
-    # Clean up after test as well
     _mock_timings_registry.clear()
-    _hospice.stage1.clear()
-    _hospice.stage2.clear()
-    _hospice.stage2_to_add.clear()
-    _hospice.hold.clear()
-    _hospice.cores.clear()
-    _hospice.refnanny.clear()
 
 
 # Global registry to simulate CoreTimings holding references to cores

{vsjetengine-1.0.0 → vsjetengine-1.2.0}/tests/test_policy.py

@@ -42,7 +42,8 @@ class TestPolicy:
 
     def test_context_manager(self, policy: Policy) -> None:
         with policy:
-            policy.api.create_environment()
+            env = policy.api.create_environment()
+            policy.api.destroy_environment(env)
 
         with pytest.raises(RuntimeError):
             policy.api.create_environment()

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

@@ -7,11 +7,16 @@
 
 import ast
 import contextlib
+import gc
+import logging
 import os
+import sys
 import textwrap
 import threading
 import types
+import weakref
 from collections.abc import Callable, Iterator
+from pathlib import Path
 from typing import Any
 
 import pytest
@@ -20,12 +25,14 @@ import vapoursynth
 from tests._testutils import BLACKBOARD
 from vsengine.adapters.asyncio import AsyncIOLoop
 from vsengine.loops import set_loop
-from vsengine.policy import GlobalStore, Policy
+from vsengine.policy import GlobalStore, ManagedEnvironment, Policy
 from vsengine.vpy import (
     ExecutionError,
     Script,
     WrapAllErrors,
     _load,
+    _ModifiedArgv0,
+    _ModifiedPath,
     chdir_runner,
     inline_runner,
     load_code,
@@ -41,7 +48,7 @@ def noop() -> Iterator[None]:
     yield
 
 
-class TestError(Exception):
+class VpyTestError(Exception):
     pass
 
 
@@ -73,7 +80,7 @@ def test_run_executes_successfully() -> None:
 def test_run_wraps_exception() -> None:
     @callback_script
     def test_code(_: types.ModuleType) -> None:
-        raise TestError()
+        raise VpyTestError()
 
     with Policy(GlobalStore()) as p, p.new_environment() as env:
         s = Script(test_code, types.ModuleType("__test__"), env.vs_environment, inline_runner)
@@ -81,7 +88,7 @@ def test_run_wraps_exception() -> None:
 
         exc = fut.exception()
         assert isinstance(exc, ExecutionError)
-        assert isinstance(exc.parent_error, TestError)
+        assert isinstance(exc.parent_error, VpyTestError)
 
 
 def test_execute_resolves_immediately() -> None:
@@ -112,14 +119,14 @@ def test_execute_resolves_to_script() -> None:
 def test_execute_resolves_immediately_when_raising() -> None:
     @callback_script
     def test_code(_: types.ModuleType) -> None:
-        raise TestError
+        raise VpyTestError
 
     with Policy(GlobalStore()) as p, p.new_environment() as env:
         s = Script(test_code, types.ModuleType("__test__"), env.vs_environment, inline_runner)
         try:
             s.result()
         except ExecutionError as err:
-            assert isinstance(err.parent_error, TestError)
+            assert isinstance(err.parent_error, VpyTestError)
         except Exception as e:
             pytest.fail(f"Wrong exception: {e!r}")
         else:
@@ -391,3 +398,182 @@ def test_wrap_exceptions_wraps_exception() -> None:
         assert e.parent_error is err
     else:
         pytest.fail("Wrap all errors swallowed the exception")
+
+
+@pytest.mark.parametrize("fail", [False, True])
+def test_dispose_clears_future(fail: bool) -> None:
+    code = "raise RuntimeError()" if fail else "pass"
+    with Policy(GlobalStore()) as p:
+        s = load_code(code, p)
+        with contextlib.suppress(ExecutionError):
+            s.result()
+
+        assert hasattr(s, "_future")
+        s.dispose()
+        assert not hasattr(s, "_future")
+
+
+def test_dispose_prevents_hospice_warning_on_error(caplog: pytest.LogCaptureFixture) -> None:
+    @callback_script
+    def test_code(mod: types.ModuleType) -> None:
+        import vapoursynth
+
+        setattr(mod, "leak", vapoursynth.core.std.BlankClip())
+        raise VpyTestError()
+
+    with Policy(GlobalStore()) as p:
+        s = Script(test_code, types.ModuleType("__test__"), p.new_environment(), inline_runner)
+        with pytest.raises(ExecutionError):
+            s.result()
+
+        s.dispose()
+
+        with caplog.at_level(logging.WARNING, logger="vsengine._hospice"):
+            for _ in range(5):
+                gc.collect()
+
+        assert not any("Core is still in use" in r.message for r in caplog.records if "vsengine._hospice" in r.name)
+
+
+def test_hospice_warns_if_future_not_deleted(caplog: pytest.LogCaptureFixture) -> None:
+    @callback_script
+    def test_code(mod: types.ModuleType) -> None:
+        import vapoursynth
+
+        setattr(mod, "clip", vapoursynth.core.std.BlankClip())
+        raise VpyTestError()
+
+    with Policy(GlobalStore()) as p:
+        env = p.new_environment()
+        s = Script(test_code, types.ModuleType("__test__"), env, inline_runner)
+        fut = s.run()
+        with pytest.raises(ExecutionError):
+            fut.result()
+
+        # Monkeypatch dispose to NOT delete the future and NOT clear module dict
+        original_dispose = s.dispose
+
+        def leaky_dispose() -> None:
+            # We ONLY dispose the environment, skipping del self._future and module.clear()
+            if isinstance(s.environment, ManagedEnvironment):
+                s.environment.dispose()
+
+        setattr(s, "dispose", leaky_dispose)
+
+        try:
+            # Clear local ref to future. It should still be held by s._future
+            del fut
+
+            s.dispose()
+
+            # Trigger hospice collection
+            with caplog.at_level(logging.WARNING, logger="vsengine._hospice"):
+                for _ in range(10):
+                    gc.collect()
+
+            # There should be a warning from hospice now because s._future still exists
+            # and is holding onto the traceback, which holds onto the module, which holds the core (via mod.clip)
+            assert any("Core is still in use" in r.message for r in caplog.records)
+        finally:
+            setattr(s, "dispose", original_dispose)
+            s.module.__dict__.clear()
+            with contextlib.suppress(AttributeError):
+                del s._future
+
+
+def test_script_is_collectible_after_dispose() -> None:
+    def _run_and_dispose() -> weakref.ReferenceType[Script[Any]]:
+        with Policy(GlobalStore()) as p:
+            s = load_code("raise RuntimeError()", p)
+            s.run()
+            s_ref = weakref.ref(s)
+            s.dispose()
+            return s_ref
+
+    s_ref = _run_and_dispose()
+
+    for _ in range(5):
+        gc.collect()
+
+    assert s_ref() is None
+
+
+def test_modified_path() -> None:
+    original_path = sys.path.copy()
+    test_path = os.path.abspath("test_path_dummy")
+    with _ModifiedPath(test_path):
+        assert sys.path[0] == test_path
+        assert test_path in sys.path
+    assert sys.path == original_path
+    assert test_path not in sys.path
+
+
+def test_modified_argv0() -> None:
+    original_argv0 = sys.argv[0]
+    test_argv0 = "test_script_argv0.py"
+    with _ModifiedArgv0(test_argv0):
+        assert sys.argv[0] == test_argv0
+    assert sys.argv[0] == original_argv0
+
+
+def test_load_script_dunder_attributes(tmp_path: Path) -> None:
+    script_path = tmp_path / "test_script.vpy"
+    script_path.write_text(
+        "from tests._testutils import BLACKBOARD; "
+        "BLACKBOARD['script_dunders'] = {k: v for k, v in globals().items() if k.startswith('__')}"
+    )
+
+    BLACKBOARD.clear()
+
+    with Policy(GlobalStore()) as p, p.new_environment() as env, env.use():
+        load_script(script_path).result()
+
+    dunders = BLACKBOARD["script_dunders"]
+    assert dunders["__file__"] == os.path.abspath(os.path.normpath(str(script_path)))
+    assert dunders["__name__"] == "__vapoursynth__"
+    assert "__cached__" in dunders
+    assert "__doc__" in dunders
+    assert "__loader__" in dunders
+    assert "__package__" in dunders
+    assert "__spec__" in dunders
+
+
+def test_load_code_dunder_attributes() -> None:
+    code = (
+        "from tests._testutils import BLACKBOARD; "
+        "BLACKBOARD['code_dunders'] = {k: v for k, v in globals().items() if k.startswith('__')}"
+    )
+
+    BLACKBOARD.clear()
+    filename = "test_code_attributes.py"
+    # Create the file so resolve works as expected if it exists check is used
+    Path(filename).touch()
+    try:
+        with Policy(GlobalStore()) as p, p.new_environment() as env, env.use():
+            load_code(code, filename=filename).result()
+
+        dunders = BLACKBOARD["code_dunders"]
+        assert dunders["__file__"] == os.path.abspath(os.path.normpath(filename))
+        assert dunders["__name__"] == "__vapoursynth__"
+    finally:
+        if os.path.exists(filename):
+            os.remove(filename)
+
+
+def test_load_script_adds_to_path(tmp_path: Path) -> None:
+    # Create a submodule in a temp directory
+    sub_dir = tmp_path / "my_module"
+    sub_dir.mkdir()
+    (sub_dir / "__init__.py").write_text("VAL = 42")
+
+    script_path = tmp_path / "main_script.vpy"
+    script_path.write_text(
+        "from tests._testutils import BLACKBOARD; import my_module; BLACKBOARD['module_val'] = my_module.VAL"
+    )
+
+    BLACKBOARD.clear()
+
+    with Policy(GlobalStore()) as p, p.new_environment() as env, env.use():
+        load_script(script_path).result()
+
+    assert BLACKBOARD["module_val"] == 42

vsjetengine-1.2.0/vsengine/_version.py

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

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

@@ -13,7 +13,7 @@ import os
 import sys
 from collections.abc import Awaitable, Buffer, Callable, Generator
 from concurrent.futures import Future
-from contextlib import AbstractContextManager
+from contextlib import AbstractContextManager, suppress
 from types import CodeType, ModuleType, TracebackType
 from typing import Any, Concatenate, Self, overload
 from uuid import uuid4
@@ -85,10 +85,9 @@ class _TempModule(AbstractContextManager[None]):
     That ensures the module is available in sys.modules during execution and restored/cleaned up afterwards.
     """
 
-    def __init__(self, mod_name: str, filename: str) -> None:
+    def __init__(self, mod_name: str, module: ModuleType | None = None) -> None:
         self.mod_name = mod_name
-        self.module = ModuleType(mod_name)
-        self.module.__dict__["__file__"] = filename
+        self.module = module or ModuleType(mod_name)
         self._saved_module = list[ModuleType | None]()
 
     def __enter__(self) -> None:
@@ -107,6 +106,56 @@ class _TempModule(AbstractContextManager[None]):
             del sys.modules[self.mod_name]
 
 
+class _ModifiedPath(AbstractContextManager[None]):
+    """
+    Temporarily add a path to sys.path.
+
+    Ported from runpy.
+    """
+
+    def __init__(self, path: str | os.PathLike[str]) -> None:
+        self.path = os.path.abspath(path)
+
+    def __enter__(self) -> None:
+        sys.path.insert(0, self.path)
+
+    def __exit__(self, exc: type[BaseException] | None, val: BaseException | None, tb: TracebackType | None) -> None:
+        with suppress(ValueError):
+            sys.path.remove(self.path)
+
+
+class _ModifiedArgv0(AbstractContextManager[None]):
+    """
+    Temporarily modify sys.argv[0].
+
+    Ported from runpy.
+    """
+
+    def __init__(self, value: Any) -> None:
+        self.value = str(value)
+        self._saved_value = ""
+
+    def __enter__(self) -> None:
+        self._saved_value = sys.argv[0]
+        sys.argv[0] = self.value
+
+    def __exit__(self, exc: type[BaseException] | None, val: BaseException | None, tb: TracebackType | None) -> None:
+        sys.argv[0] = self._saved_value
+
+
+def _set_module_dunders(module: ModuleType, filename: str) -> None:
+    for key, value in {
+        "__name__": module.__name__,
+        "__file__": filename,
+        "__cached__": None,
+        "__doc__": None,
+        "__loader__": None,
+        "__package__": None,
+        "__spec__": None,
+    }.items():
+        module.__dict__.setdefault(key, value)
+
+
 def inline_runner[T](func: Callable[[], T]) -> Future[T]:
     """
     Runs a function inline and returns the result as a Future.
@@ -208,6 +257,7 @@ class Script[EnvT: (vs.Environment, ManagedEnvironment)](AbstractContextManager[
 
     def dispose(self) -> None:
         """Disposes the managed environment and clears the module globals."""
+        self._del_future_refs()
         self.module.__dict__.clear()
 
         if isinstance(self.environment, ManagedEnvironment):
@@ -236,6 +286,14 @@ class Script[EnvT: (vs.Environment, ManagedEnvironment)](AbstractContextManager[
         with self.environment.use():
             self.executor(WrapAllErrors(), self.module)
 
+    def _del_future_refs(self) -> None:
+        if (fut := getattr(self, "_future", None)) is not None:
+            if fut.done() and not fut.cancelled() and (exc := fut.exception()):
+                exc.__traceback__ = None
+                if isinstance(exc, ExecutionError) and (parent := exc.parent_error):
+                    parent.__traceback__ = None
+            del self._future
+
 
 @overload
 def load_script(
@@ -300,18 +358,22 @@ def load_script(
                   This is unsafe when running multiple scripts at once.
     :returns: A script object. The script starts running when you call run() on it, or await it.
     """
+    rscript = os.path.abspath(os.path.normpath(str(script)))
 
     def _execute(ctx: WrapAllErrors, module: ModuleType) -> None:
-        nonlocal script
-
-        script = str(script)
-
-        with ctx, io.open_code(script) as f, _TempModule(module.__name__, script):
-            exec(
-                compile(f.read(), filename=script, dont_inherit=True, flags=0, mode="exec"),
-                module.__dict__,
-                module.__dict__,
-            )
+        path = os.path.dirname(rscript)
+
+        with (
+            ctx,
+            _TempModule(module.__name__, module),
+            _ModifiedPath(path),
+            _ModifiedArgv0(rscript),
+            io.open_code(rscript) as f,
+        ):
+            _set_module_dunders(module, rscript)
+
+            code = compile(f.read(), filename=rscript, dont_inherit=True, flags=0, mode="exec")
+            exec(code, module.__dict__, module.__dict__)
 
     return _load(_execute, environment, module, inline, chdir)
 
@@ -384,25 +446,28 @@ def load_code(
     :param chdir: Change the currently running directory while the script is running.
                   This is unsafe when running multiple scripts at once.
     :returns: A script object. The script starts running when you call run() on it, or await it.
+    :kwargs: Arguments to pass to compile().
     """
+    if "filename" in kwargs:
+        kwargs["filename"] = os.path.abspath(os.path.normpath(str(kwargs["filename"])))
 
     def _execute(ctx: WrapAllErrors, module: ModuleType) -> None:
-        nonlocal script, kwargs
-
         filename = kwargs.pop("filename", f"<runvpy {uuid4().hex[:8]}>")
+        path = os.path.dirname(filename) if os.path.exists(filename) else None
+
+        with (
+            ctx,
+            _TempModule(module.__name__, module),
+            _ModifiedPath(path) if path else ctx,
+            _ModifiedArgv0(filename) if path else ctx,
+        ):
+            code = (
+                compile(script, **{"filename": filename, "dont_inherit": True, "flags": 0, "mode": "exec"} | kwargs)
+                if not isinstance(script, CodeType)
+                else script
+            )
 
-        with ctx, _TempModule(module.__name__, filename):
-            if isinstance(script, CodeType):
-                code = script
-            else:
-                compile_args: dict[str, Any] = {
-                    "filename": filename,
-                    "dont_inherit": True,
-                    "flags": 0,
-                    "mode": "exec",
-                } | kwargs
-                code = compile(script, **compile_args)
-
+            _set_module_dunders(module, filename)
             exec(code, module.__dict__, module.__dict__)
 
     return _load(_execute, environment, module, inline, chdir)

vsjetengine-1.0.0/vsengine/_version.py

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