vsview 0.1.0__py3-none-any.whl

vsview/__init__.py

@@ -0,0 +1,3 @@
+from .api import catch_output, is_preview, set_output
+
+__all__ = ["catch_output", "is_preview", "set_output"]

vsview/api/__init__.py

@@ -0,0 +1,87 @@
+"""API for vsview"""
+
+from ..app.plugins import (
+    AudioOutputProxy,
+    GraphicsViewProxy,
+    LocalSettingsModel,
+    NodeProcessor,
+    PluginAPI,
+    PluginGraphicsView,
+    PluginSecrets,
+    PluginSettings,
+    VideoOutputProxy,
+    WidgetPluginBase,
+    hookimpl,
+)
+from ..app.settings.models import (
+    ActionDefinition,
+    Checkbox,
+    ColorPicker,
+    ColorPickerInput,
+    DoubleSpin,
+    Dropdown,
+    LineEdit,
+    ListEdit,
+    ListEditWidget,
+    Login,
+    LoginCredentialsInput,
+    PlainTextEdit,
+    Spin,
+    WidgetMetadata,
+    WidgetTimeEdit,
+)
+from ..app.views import OutputInfo
+from ..app.views.components import AbstractTableModel, Accordion, AnimatedToggle, NonClosingMenu, SegmentedControl
+from ..app.views.timeline import Frame, FrameEdit, Time, TimeEdit
+from ..app.views.video import BaseGraphicsView
+from ..assets import IconName, IconReloadMixin
+from ..vsenv import run_in_background, run_in_loop
+from .info import is_preview
+from .output import catch_output, set_output
+
+__all__ = [
+    "AbstractTableModel",
+    "Accordion",
+    "ActionDefinition",
+    "AnimatedToggle",
+    "AudioOutputProxy",
+    "BaseGraphicsView",
+    "Checkbox",
+    "ColorPicker",
+    "ColorPickerInput",
+    "DoubleSpin",
+    "Dropdown",
+    "Frame",
+    "FrameEdit",
+    "GraphicsViewProxy",
+    "IconName",
+    "IconReloadMixin",
+    "LineEdit",
+    "ListEdit",
+    "ListEditWidget",
+    "LocalSettingsModel",
+    "Login",
+    "LoginCredentialsInput",
+    "NodeProcessor",
+    "NonClosingMenu",
+    "OutputInfo",
+    "PlainTextEdit",
+    "PluginAPI",
+    "PluginGraphicsView",
+    "PluginSecrets",
+    "PluginSettings",
+    "SegmentedControl",
+    "Spin",
+    "Time",
+    "TimeEdit",
+    "VideoOutputProxy",
+    "WidgetMetadata",
+    "WidgetPluginBase",
+    "WidgetTimeEdit",
+    "catch_output",
+    "hookimpl",
+    "is_preview",
+    "run_in_background",
+    "run_in_loop",
+    "set_output",
+]

vsview/api/_helpers.py

@@ -0,0 +1,53 @@
+from collections import UserDict, defaultdict
+from collections.abc import Callable, Sequence
+from os import PathLike
+from typing import Any, Literal, NamedTuple
+
+from jetpytools import copy_signature
+
+
+class VideoMetadata(NamedTuple):
+    name: str
+    framedurs: Sequence[float] | None
+    alpha_prop: Literal[True] | None
+
+
+class AudioMetadata(NamedTuple):
+    name: str
+    downmix: bool | None
+
+
+class DefaultUserDict[K, V](UserDict[K, V]):
+    @copy_signature(defaultdict[K, V].__init__)
+    def __init__(self, default_factory: Callable[[], V] | None = None, /, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.default_factory = default_factory
+
+    def __missing__(self, key: K) -> V:
+        if self.default_factory is None:
+            raise KeyError(key)
+
+        new_value = self.default_factory()
+
+        self.data[key] = new_value
+
+        return new_value
+
+
+class OutputMetadata(DefaultUserDict[str, dict[int, Any]]):
+    def _hash_key(self, key: str | PathLike[str]) -> str:
+        from ..app.utils import path_to_hash
+
+        return path_to_hash(key)
+
+    def __getitem__(self, key: str | PathLike[str]) -> dict[int, Any]:
+        return super().__getitem__(self._hash_key(key))
+
+    def __setitem__(self, key: str | PathLike[str], value: dict[int, Any]) -> None:
+        super().__setitem__(self._hash_key(key), value)
+
+    def __contains__(self, key: object) -> bool:
+        return super().__contains__(self._hash_key(str(key)))
+
+
+output_metadata = OutputMetadata(dict)

vsview/api/info.py

@@ -0,0 +1,6 @@
+import sys
+
+
+def is_preview() -> bool:
+    """Check if the current script is running in a preview environment (VSView only)."""
+    return bool(sys.modules.get("__vsview__"))

vsview/api/output.py

@@ -0,0 +1,338 @@
+"""
+Output registration API for vsview.
+"""
+
+from __future__ import annotations
+
+import sys
+from collections.abc import Callable, Iterable, Sequence
+from copy import deepcopy
+from functools import wraps
+from logging import getLogger
+from typing import Any, Literal, assert_never, overload
+
+import vapoursynth as vs
+from jetpytools import CustomValueError, flatten, to_arr
+
+from ._helpers import AudioMetadata, VideoMetadata
+from ._helpers import output_metadata as _output_metadata
+
+_logger = getLogger(__name__)
+
+type VideoNodeIterable = Iterable[vs.VideoNode | VideoNodeIterable]
+type AudioNodeIterable = Iterable[vs.AudioNode | AudioNodeIterable]
+type OutputNode = vs.VideoNode | vs.AudioNode | VideoNodeIterable | AudioNodeIterable
+
+# ScenesT = Keyframes | list[tuple[int, int]] | list[Keyframes | list[tuple[int, int]]] | None
+
+
+# VideoNode signature
+@overload
+def set_output(
+    node: vs.VideoNode,
+    index: int = ...,
+    /,
+    *,
+    alpha: vs.VideoNode | Literal[True] | None = ...,
+    framedurs: Sequence[float] | None = None,
+    # scenes: ScenesT = None,
+    **kwargs: Any,
+) -> None: ...
+
+
+@overload
+def set_output(
+    node: vs.VideoNode,
+    name: str | bool | None = ...,
+    /,
+    *,
+    alpha: vs.VideoNode | Literal[True] | None = ...,
+    framedurs: Sequence[float] | None = None,
+    # scenes: ScenesT = None,
+    **kwargs: Any,
+) -> None: ...
+
+
+@overload
+def set_output(
+    node: vs.VideoNode,
+    index: int = ...,
+    name: str | bool | None = ...,
+    /,
+    alpha: vs.VideoNode | Literal[True] | None = ...,
+    *,
+    framedurs: Sequence[float] | None = None,
+    # scenes: ScenesT = None,
+    **kwargs: Any,
+) -> None: ...
+
+
+# AudioNode signature
+@overload
+def set_output(
+    node: vs.AudioNode,
+    index: int = ...,
+    /,
+    *,
+    downmix: bool | None = None,
+    **kwargs: Any,
+) -> None: ...
+
+
+@overload
+def set_output(
+    node: vs.AudioNode,
+    name: str | bool | None = ...,
+    /,
+    *,
+    downmix: bool | None = None,
+    **kwargs: Any,
+) -> None: ...
+
+
+@overload
+def set_output(
+    node: vs.AudioNode,
+    index: int = ...,
+    name: str | bool | None = ...,
+    /,
+    *,
+    downmix: bool | None = None,
+    **kwargs: Any,
+) -> None: ...
+
+
+@overload
+def set_output(
+    node: VideoNodeIterable | AudioNodeIterable, index: int | Sequence[int] = ..., /, **kwargs: Any
+) -> None: ...
+
+
+@overload
+def set_output(
+    node: VideoNodeIterable | AudioNodeIterable, name: str | bool | None = ..., /, **kwargs: Any
+) -> None: ...
+
+
+@overload
+def set_output(
+    node: VideoNodeIterable | AudioNodeIterable,
+    index: int | Sequence[int] = ...,
+    name: str | bool | None = ...,
+    /,
+    **kwargs: Any,
+) -> None: ...
+
+
+def set_output(
+    node: OutputNode,
+    index_or_name: int | Sequence[int] | str | bool | None = None,
+    name: str | bool | None = None,
+    /,
+    alpha: vs.VideoNode | Literal[True] | None = None,
+    *,
+    framedurs: Sequence[float] | None = None,
+    # scenes: ScenesT = None,
+    downmix: bool | None = None,
+    **kwargs: Any,
+) -> None:
+    """
+    Register one or more VapourSynth nodes as outputs for preview.
+
+    This function sets the output(s) and registers metadata for tab naming in vsview.
+    If no index is provided, outputs are assigned to the next available indices.
+
+    Examples:
+        ```python
+        set_output(clip)  # Auto-index, auto-name ("clip")
+        set_output(clip, 0)  # Index 0, auto-name
+        set_output(clip, 0, "My Clip")  # Index 0, explicit name
+        set_output(clip, "Source")  # Auto-index, explicit name
+        set_output([clip1, clip2])  # Multiple outputs
+        ```
+
+    Args:
+        node: A VideoNode, AudioNode, or iterable of nodes to output.
+        index_or_name: Either:
+
+               - An int or sequence of ints specifying output indices
+               - A str to use as the output name
+               - True/None to auto-detect the variable name
+               - False to disable name detection
+
+        name: Explicit name override. If provided when index_or_name is an int,
+            this sets the display name for the output.
+        alpha: Optional alpha channel VideoNode or if True, fetch the `_Alpha` prop (only for VideoNode outputs).
+        framedurs: Optional sequence of frame durations in seconds for VFR clips (only for VideoNode outputs).
+        downmix: if None (default), follows the global settings downmix of vsview if previewed
+            through vsview. Otherwise True or False forces the behavior.
+        **kwargs: Additional keyword arguments (reserved for future use).
+    """
+    if isinstance(index_or_name, (str, bool)):
+        index = None
+        name = index_or_name
+    else:
+        index = index_or_name
+
+    outputs = vs.get_outputs()
+    nodes = list[vs.VideoNode | vs.AudioNode](flatten([node]))
+
+    indices = to_arr(index) if index is not None else [max(outputs, default=-1) + 1]
+
+    while len(indices) < len(nodes):
+        indices.append(indices[-1] + 1)
+
+    frame_depth = kwargs.pop("frame_depth", 1) + 1
+    script_module = sys.modules.get("__vsview__")
+
+    for i, n in zip(indices[: len(nodes)], nodes):
+        if i in outputs:
+            _logger.warning("Output index %d already in use; overwriting.", i)
+
+        match n:
+            case vs.VideoNode():
+                n.set_output(i, alpha if alpha is not True else None)
+                title = "Clip"
+            case vs.AudioNode():
+                n.set_output(i)
+                title = "Audio"
+            case _:
+                assert_never(n)
+
+        if not script_module:
+            continue
+
+        effective_name: str | None
+
+        match name:
+            case True | None:
+                effective_name = _resolve_var_name(n, frame_depth=frame_depth)
+            case False:
+                effective_name = None
+            case str():
+                effective_name = name
+
+        if file := getattr(script_module, "__file__", None):
+            if isinstance(n, vs.VideoNode):
+                if framedurs and len(framedurs) != n.num_frames:
+                    raise CustomValueError(
+                        "framedurs length must match number of frames", kwargs.get("func", set_output)
+                    )
+
+                _output_metadata[file][i] = VideoMetadata(
+                    effective_name or f"{title} {i}",
+                    deepcopy(framedurs),
+                    alpha is True or None,
+                )
+            elif isinstance(n, vs.AudioNode):
+                _output_metadata[file][i] = AudioMetadata(effective_name or f"{title} {i}", downmix)
+
+        #     if scenes:
+        #         set_scening(scenes, n, effective_name or f"{title} {i}")
+
+
+@overload
+def catch_output[**P, N: OutputNode](func: Callable[P, N], /) -> Callable[P, N]: ...
+
+
+@overload
+def catch_output[**P, N: OutputNode](
+    *,
+    index: int | Sequence[int] = ...,
+    name: str | bool | None = ...,
+    alpha: vs.VideoNode | Literal[True] | None = ...,
+    framedurs: Sequence[float] | None = ...,
+    downmix: bool | None = ...,
+    **kwargs: Any,
+) -> Callable[[Callable[P, N]], Callable[P, N]]: ...
+
+
+def catch_output[**P, N: OutputNode](
+    func: Callable[P, N] | None = None,
+    /,
+    index: int | Sequence[int] | None = None,
+    name: str | bool | None = None,
+    alpha: vs.VideoNode | Literal[True] | None = None,
+    *,
+    framedurs: Sequence[float] | None = None,
+    downmix: bool | None = None,
+    **kwargs: Any,
+) -> Callable[P, N] | Callable[[Callable[P, N]], Callable[P, N]]:
+    """
+    Decorator variant of `set_output()`.
+
+    Calls the decorated function and registers its return value as an output.
+
+    Examples:
+        ```python
+        @catch_output
+        def source() -> vs.VideNode:
+            return vs.core.bs.BestSource("video.mkv")
+
+
+        @catch_output(name="Filtered", alpha=True)
+        def filtered() -> vs.VideNode:
+            src = vs.core.bs.BestSource("image.png")
+            return src.std.BoxBlur()
+        ```
+
+    Args:
+        func: The function to decorate (populated automatically when used as a bare decorator).
+        index: An int or sequence of ints specifying output indices
+        name: Explicit name override. If not provided, the function name is used.
+        alpha: Optional alpha channel VideoNode or if True, fetch the `_Alpha` prop (only for VideoNode outputs).
+        framedurs: Optional sequence of frame durations in seconds for VFR clips (only for VideoNode outputs).
+        downmix: If None (default), follows the global settings downmix of vsview if previewed through vsview.
+            Otherwise True or False forces the behavior.
+        **kwargs: Additional keyword arguments forwarded to :func:`set_output`.
+
+    Returns:
+        The decorated function (its original return type is preserved).
+    """
+
+    def decorator(fn: Callable[P, N]) -> Callable[P, N]:
+        @wraps(fn)
+        def wrapper(*fn_args: P.args, **fn_kwargs: P.kwargs) -> N:
+            nonlocal name
+
+            result = fn(*fn_args, **fn_kwargs)
+
+            if name is True or name is None:
+                name = fn.__name__
+
+            set_output(  # type: ignore[misc]
+                result,  # type: ignore[arg-type]
+                index,  # type: ignore[arg-type]
+                name,
+                alpha=alpha,
+                framedurs=framedurs,
+                downmix=downmix,
+                **kwargs,
+            )
+
+            return result
+
+        return wrapper
+
+    if func is not None:
+        return decorator(func)
+
+    return decorator
+
+
+def _resolve_var_name(obj: Any, *, frame_depth: int = 1) -> str | None:
+    try:
+        frame = sys._getframe(frame_depth)
+    except ValueError:
+        return None
+
+    try:
+        obj_id = id(obj)
+
+        for var_name, value in reversed(list(frame.f_locals.items())):
+            if id(value) == obj_id:
+                return var_name
+
+        return None
+    finally:
+        del frame

vsview/app/error.py

@@ -0,0 +1,102 @@
+import linecache
+from logging import getLogger
+from pathlib import Path
+from traceback import TracebackException
+
+from PySide6.QtGui import QFontMetrics
+from PySide6.QtWidgets import QGridLayout, QMessageBox, QSpacerItem, QStyle, QWidget
+from vsengine.vpy import ExecutionError
+
+from ..assets import get_monospace_font
+from ..vsenv import run_in_loop
+
+logger = getLogger(__name__)
+
+
+def _is_user_script_frame(filename: str, user_script_path: str | None = None) -> bool:
+    normalized_filename = filename.lower().replace("\\", "/")
+
+    if user_script_path:
+        normalized_script = user_script_path.lower().replace("\\", "/")
+
+        if (normalized_filename == normalized_script) or (
+            user_script_path.startswith("<") and filename == user_script_path
+        ):
+            return True
+
+    if filename.startswith(("src/cython/", "<")):
+        return False
+
+    return not any(
+        marker in normalized_filename for marker in ("site-packages/", "/lib/", ".venv/", "venv/", "lib/python")
+    )
+
+
+def _find_user_script_frame(tb: TracebackException, user_script_path: str | None = None) -> tuple[str, int] | None:
+    if not tb.stack:
+        return None
+
+    # Walk backwards from the last frame to find a user script frame
+    for frame in reversed(tb.stack):
+        if frame.filename and frame.lineno is not None and _is_user_script_frame(frame.filename, user_script_path):
+            return (frame.filename, frame.lineno)
+
+    return None
+
+
+@run_in_loop(return_future=False)
+def show_error(error: ExecutionError, parent: QWidget, user_script_path: str | None = None) -> None:
+    e = error.parent_error
+
+    logger.error("Full traceback:", exc_info=e)
+
+    tb = TracebackException.from_exception(e)
+    context = list[str]()
+
+    # For SyntaxError, get location from the error itself, not the traceback
+    # (traceback points to vsengine's compile() call, not the user's script)
+    if isinstance(e, SyntaxError) and e.filename is not None and e.lineno is not None:
+        filename, lineno = e.filename, e.lineno
+    elif result := _find_user_script_frame(tb, user_script_path):
+        filename, lineno = result
+    else:
+        filename, lineno = None, None
+
+    if filename and lineno:
+        # Try reading from real file first, then fall back to linecache (for virtual files)
+        if not filename.startswith("<") and (p := Path(filename)).exists():
+            lines = p.read_text().splitlines()
+        else:
+            lines = [line.rstrip("\n\r") for line in linecache.getlines(filename)]
+
+        if lines:
+            context.append(f"File: {filename}:{lineno}")
+
+            for i in range(max(0, lineno - 4), min(len(lines), lineno + 3)):
+                prefix = ">" if i + 1 == lineno else " "
+                context.append(f"{prefix}{i + 1:3d} | {lines[i]}")
+        else:
+            context.append(f"File: {filename}:{lineno}")
+            context.append("(source code not available)")
+    else:
+        context.append("(no traceback information available)")
+
+    header = f"A {e.__class__.__name__} exception was raised while running the script."
+    error_message = f"{header}\n\n{'\n'.join(context)}\n\n{e.__class__.__name__}: {e}\n"
+
+    font = get_monospace_font()
+    metrics = QFontMetrics(font)
+
+    max_width = max(metrics.horizontalAdvance(line) for line in error_message.splitlines())
+
+    msg = QMessageBox(parent)
+    msg.setIconPixmap(msg.style().standardIcon(QStyle.StandardPixmap.SP_MessageBoxCritical).pixmap(48, 48))
+    msg.setWindowTitle("Error")
+    msg.setText(error_message)
+    msg.setFont(font)
+
+    if isinstance(layout := msg.layout(), QGridLayout):
+        spacer = QSpacerItem(max_width, 0)
+        layout.addItem(spacer, layout.rowCount(), 0, 1, layout.columnCount())
+
+    msg.exec()