videopython 0.25.8__tar.gz → 0.26.1__tar.gz

{videopython-0.25.8 → videopython-0.26.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: videopython
-Version: 0.25.8
+Version: 0.26.1
 Summary: Minimal video generation and processing library.
 Project-URL: Homepage, https://videopython.com
 Project-URL: Repository, https://github.com/bartwojtowicz/videopython/

{videopython-0.25.8 → videopython-0.26.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "videopython"
-version = "0.25.8"
+version = "0.26.1"
 description = "Minimal video generation and processing library."
 authors = [
     { name = "Bartosz Wójtowicz", email = "bartoszwojtowicz@outlook.com" },

{videopython-0.25.8 → videopython-0.26.1}/src/videopython/ai/dubbing/dubber.py

@@ -36,12 +36,15 @@ class VideoDubber:
         voice_clone: bool = True,
         enable_diarization: bool = False,
         progress_callback: Callable[[str, float], None] | None = None,
+        transcription: Any = None,
     ) -> DubbingResult:
         """Dub a video into a target language.
 
         Args:
             enable_diarization: Enable speaker diarization to clone each speaker's
                 voice separately. Requires additional VRAM for the diarization model.
+            transcription: Optional pre-computed Transcription object. When provided,
+                the internal Whisper transcription step is skipped.
         """
         if self._local_pipeline is None:
             self._init_local_pipeline()
@@ -54,6 +57,7 @@ class VideoDubber:
             voice_clone=voice_clone,
             enable_diarization=enable_diarization,
             progress_callback=progress_callback,
+            transcription=transcription,
         )
 
     def dub_and_replace(
@@ -65,8 +69,14 @@ class VideoDubber:
         voice_clone: bool = True,
         enable_diarization: bool = False,
         progress_callback: Callable[[str, float], None] | None = None,
+        transcription: Any = None,
     ) -> Video:
-        """Dub a video and return a new video with the dubbed audio."""
+        """Dub a video and return a new video with the dubbed audio.
+
+        Args:
+            transcription: Optional pre-computed Transcription object. When provided,
+                the internal Whisper transcription step is skipped.
+        """
         result = self.dub(
             video=video,
             target_lang=target_lang,
@@ -75,6 +85,7 @@ class VideoDubber:
             voice_clone=voice_clone,
             enable_diarization=enable_diarization,
             progress_callback=progress_callback,
+            transcription=transcription,
         )
         return video.add_audio(result.dubbed_audio, overlay=False)
 

{videopython-0.25.8 → videopython-0.26.1}/src/videopython/ai/dubbing/pipeline.py

@@ -114,21 +114,33 @@ class LocalDubbingPipeline:
         voice_clone: bool = True,
         enable_diarization: bool = False,
         progress_callback: Callable[[str, float], None] | None = None,
+        transcription: Any | None = None,
     ) -> DubbingResult:
-        """Process a video through the local dubbing pipeline."""
+        """Process a video through the local dubbing pipeline.
+
+        Args:
+            transcription: Optional pre-computed Transcription object. When provided,
+                the internal Whisper transcription step is skipped (saving time and VRAM).
+                Must be a ``videopython.base.text.transcription.Transcription`` instance
+                with populated ``segments``.
+        """
         from videopython.base.audio import Audio
 
         def report_progress(stage: str, progress: float) -> None:
             if progress_callback:
                 progress_callback(stage, progress)
 
-        report_progress("Transcribing audio", 0.05)
-        if self._transcriber is None or self._transcriber_diarization != enable_diarization:
-            self._init_transcriber(enable_diarization=enable_diarization)
-            self._transcriber_diarization = enable_diarization
-
         source_audio = video.audio
-        transcription = self._transcriber.transcribe(source_audio)
+
+        if transcription is not None:
+            report_progress("Using provided transcription", 0.05)
+        else:
+            report_progress("Transcribing audio", 0.05)
+            if self._transcriber is None or self._transcriber_diarization != enable_diarization:
+                self._init_transcriber(enable_diarization=enable_diarization)
+                self._transcriber_diarization = enable_diarization
+
+            transcription = self._transcriber.transcribe(source_audio)
 
         if not transcription.segments:
             return DubbingResult(

{videopython-0.25.8 → videopython-0.26.1}/src/videopython/ai/generation/translation.py

@@ -48,6 +48,15 @@ LANGUAGE_NAMES = {
 class TextTranslator:
     """Translates text between languages using local seq2seq models."""
 
+    # Languages without a direct opus-mt-{src}-{tgt} model. Maps (source, target)
+    # to an alternative HuggingFace model identifier.
+    _MODEL_OVERRIDES: dict[tuple[str, str], str] = {
+        ("en", "pt"): "Helsinki-NLP/opus-mt-tc-big-en-pt",
+        ("en", "ko"): "Helsinki-NLP/opus-mt-tc-big-en-ko",
+        ("en", "ja"): "Helsinki-NLP/opus-mt-en-jap",
+        ("en", "pl"): "Helsinki-NLP/opus-mt-en-zlw",
+    }
+
     def __init__(self, model_name: str | None = None, device: str | None = None):
         self.model_name = model_name
         self.device = device
@@ -58,6 +67,9 @@ class TextTranslator:
     def _get_local_model_name(self, source_lang: str, target_lang: str) -> str:
         if self.model_name:
             return self.model_name
+        override = self._MODEL_OVERRIDES.get((source_lang, target_lang))
+        if override:
+            return override
         return f"Helsinki-NLP/opus-mt-{source_lang}-{target_lang}"
 
     def _init_local(self, source_lang: str, target_lang: str) -> None:

{videopython-0.25.8 → videopython-0.26.1}/src/videopython/base/effects.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Literal
+from typing import TYPE_CHECKING, ClassVar, Literal
 
 import cv2
 import numpy as np
@@ -11,6 +11,7 @@ from videopython.base.progress import log, progress_iter
 from videopython.base.video import Video
 
 if TYPE_CHECKING:
+    from videopython.base.audio import Audio
     from videopython.base.description import BoundingBox
 
 __all__ = [
@@ -50,6 +51,27 @@ class Effect(ABC):
     The effect must not change the number of frames and the shape of the frames.
     """
 
+    supports_streaming: ClassVar[bool] = False
+
+    def streaming_init(self, total_frames: int, fps: float, width: int, height: int) -> None:
+        """Called once before streaming begins to precompute per-frame parameters.
+
+        Override in subclasses that need precomputation (e.g., per-frame alpha
+        arrays, sigma schedules, crop regions).
+        """
+
+    def process_frame(self, frame: np.ndarray, frame_index: int) -> np.ndarray:
+        """Process a single frame in streaming mode.
+
+        Args:
+            frame: Single RGB frame (H, W, 3) uint8.
+            frame_index: 0-based index within this effect's active range.
+
+        Returns:
+            Processed frame, same shape and dtype.
+        """
+        raise NotImplementedError(f"{type(self).__name__} does not support streaming")
+
     def apply(self, video: Video, start: float | None = None, stop: float | None = None) -> Video:
         """Apply the effect to a video, optionally within a time range.
 
@@ -106,6 +128,8 @@ class FullImageOverlay(Effect):
     transparency via RGBA images and an overall opacity control.
     """
 
+    supports_streaming: ClassVar[bool] = True
+
     def __init__(self, overlay_image: np.ndarray, alpha: float | None = None, fade_time: float = 0.0):
         """Initialize image overlay effect.
 
@@ -139,6 +163,17 @@ class FullImageOverlay(Effect):
         img_pil.paste(overlay_pil, (0, 0), overlay_pil)
         return np.array(img_pil)
 
+    def streaming_init(self, total_frames: int, fps: float, width: int, height: int) -> None:
+        self._stream_total = total_frames
+        self._stream_fade_frames = round(self.fade_time * fps) if self.fade_time > 0 else 0
+
+    def process_frame(self, frame: np.ndarray, frame_index: int) -> np.ndarray:
+        if self._stream_fade_frames == 0:
+            return self._overlay(frame)
+        dist_from_end = min(frame_index, self._stream_total - 1 - frame_index)
+        fade_alpha = 1.0 if dist_from_end >= self._stream_fade_frames else dist_from_end / self._stream_fade_frames
+        return self._overlay(frame, fade_alpha)
+
     def _apply(self, video: Video) -> Video:
         if not video.frame_shape == self.overlay[:, :, :3].shape:
             raise ValueError(
@@ -164,6 +199,8 @@ class FullImageOverlay(Effect):
 class Blur(Effect):
     """Applies Gaussian blur that can stay constant or ramp up/down over the clip."""
 
+    supports_streaming: ClassVar[bool] = True
+
     def __init__(
         self,
         mode: Literal["constant", "ascending", "descending"],
@@ -198,29 +235,31 @@ class Blur(Effect):
         """
         return cv2.GaussianBlur(frame, self.kernel_size, sigma)
 
-    def _apply(self, video: Video) -> Video:
-        n_frames = len(video.frames)
-
-        # Calculate base sigma from kernel size (OpenCV formula)
+    def _compute_sigmas(self, n_frames: int) -> np.ndarray:
+        """Compute per-frame sigma values based on mode."""
         base_sigma = 0.3 * ((self.kernel_size[0] - 1) * 0.5 - 1) + 0.8
-
-        # Multiple blur iterations with sigma S approximate single blur with sigma S*sqrt(iterations)
-        # This is much faster than iterative application
         max_sigma = base_sigma * np.sqrt(self.iterations)
 
-        # Calculate sigma for each frame based on mode
         if self.mode == "constant":
-            sigmas = np.full(n_frames, max_sigma)
+            return np.full(n_frames, max_sigma)
         elif self.mode == "ascending":
-            # Linearly increase blur intensity from start to end
-            iteration_ratios = np.linspace(1 / n_frames, 1.0, n_frames)
-            sigmas = base_sigma * np.sqrt(np.maximum(1, np.round(iteration_ratios * self.iterations)))
+            ratios = np.linspace(1 / n_frames, 1.0, n_frames)
         elif self.mode == "descending":
-            # Linearly decrease blur intensity from start to end
-            iteration_ratios = np.linspace(1.0, 1 / n_frames, n_frames)
-            sigmas = base_sigma * np.sqrt(np.maximum(1, np.round(iteration_ratios * self.iterations)))
+            ratios = np.linspace(1.0, 1 / n_frames, n_frames)
         else:
             raise ValueError(f"Unknown mode: `{self.mode}`.")
+        return base_sigma * np.sqrt(np.maximum(1, np.round(ratios * self.iterations)))
+
+    def streaming_init(self, total_frames: int, fps: float, width: int, height: int) -> None:
+        self._stream_sigmas = self._compute_sigmas(total_frames)
+
+    def process_frame(self, frame: np.ndarray, frame_index: int) -> np.ndarray:
+        idx = min(frame_index, len(self._stream_sigmas) - 1)
+        return self._blur_frame(frame, self._stream_sigmas[idx])
+
+    def _apply(self, video: Video) -> Video:
+        n_frames = len(video.frames)
+        sigmas = self._compute_sigmas(n_frames)
 
         log(f"Applying {self.mode} blur...")
         for i in progress_iter(range(n_frames), desc="Blurring"):
@@ -231,6 +270,8 @@ class Blur(Effect):
 class Zoom(Effect):
     """Progressively zooms into or out of the frame center over the clip duration."""
 
+    supports_streaming: ClassVar[bool] = True
+
     def __init__(self, zoom_factor: float, mode: Literal["in", "out"]):
         """Initialize zoom effect.
 
@@ -245,6 +286,24 @@ class Zoom(Effect):
         self.zoom_factor = zoom_factor
         self.mode = mode
 
+    def streaming_init(self, total_frames: int, fps: float, width: int, height: int) -> None:
+        crop_w = np.linspace(width // self.zoom_factor, width, total_frames)
+        crop_h = np.linspace(height // self.zoom_factor, height, total_frames)
+        if self.mode == "in":
+            crop_w, crop_h = crop_w[::-1], crop_h[::-1]
+        self._stream_crops = np.stack([crop_w, crop_h], axis=1)
+        self._stream_width = width
+        self._stream_height = height
+
+    def process_frame(self, frame: np.ndarray, frame_index: int) -> np.ndarray:
+        idx = min(frame_index, len(self._stream_crops) - 1)
+        w, h = self._stream_crops[idx]
+        width, height = self._stream_width, self._stream_height
+        x = width / 2 - w / 2
+        y = height / 2 - h / 2
+        cropped = frame[round(y) : round(y + h), round(x) : round(x + w)]
+        return cv2.resize(cropped, (width, height))
+
     def _apply(self, video: Video) -> Video:
         n_frames = len(video.frames)
         width = video.metadata.width
@@ -270,6 +329,8 @@ class Zoom(Effect):
 class ColorGrading(Effect):
     """Adjusts color properties: brightness, contrast, saturation, and temperature."""
 
+    supports_streaming: ClassVar[bool] = True
+
     def __init__(
         self,
         brightness: float = 0.0,
@@ -335,6 +396,9 @@ class ColorGrading(Effect):
         img = np.clip(img * 255, 0, 255).astype(np.uint8)
         return img
 
+    def process_frame(self, frame: np.ndarray, frame_index: int) -> np.ndarray:
+        return self._grade_frame(frame)
+
     def _apply(self, video: Video) -> Video:
         log("Applying color grading...")
         for i in progress_iter(range(len(video.frames)), desc="Color grading"):
@@ -345,6 +409,8 @@ class ColorGrading(Effect):
 class Vignette(Effect):
     """Darkens the edges of the frame, drawing attention to the center."""
 
+    supports_streaming: ClassVar[bool] = True
+
     def __init__(self, strength: float = 0.5, radius: float = 1.0):
         """Initialize vignette effect.
 
@@ -378,6 +444,14 @@ class Vignette(Effect):
 
         return mask.astype(np.float32)
 
+    def streaming_init(self, total_frames: int, fps: float, width: int, height: int) -> None:
+        if self._mask is None or self._mask.shape != (height, width):
+            self._mask = self._create_mask(height, width)
+        self._stream_mask_3d = self._mask[:, :, np.newaxis]
+
+    def process_frame(self, frame: np.ndarray, frame_index: int) -> np.ndarray:
+        return (frame.astype(np.float32) * self._stream_mask_3d).astype(np.uint8)
+
     def _apply(self, video: Video) -> Video:
         log("Applying vignette effect...")
         height, width = video.frame_shape[:2]
@@ -403,6 +477,8 @@ class KenBurns(Effect):
     across a scene.
     """
 
+    supports_streaming: ClassVar[bool] = True
+
     def __init__(
         self,
         start_region: "BoundingBox",
@@ -477,6 +553,38 @@ class KenBurns(Effect):
         cropped = frame[y : y + crop_h, x : x + crop_w]
         return cv2.resize(cropped, (target_w, target_h), interpolation=cv2.INTER_LINEAR)
 
+    def _precompute_regions(self, n_frames: int, width: int, height: int) -> np.ndarray:
+        """Precompute (x, y, crop_w, crop_h) for each frame."""
+        sx = int(self.start_region.x * width)
+        sy = int(self.start_region.y * height)
+        sw = int(self.start_region.width * width)
+        sh = int(self.start_region.height * height)
+        ex = int(self.end_region.x * width)
+        ey = int(self.end_region.y * height)
+        ew = int(self.end_region.width * width)
+        eh = int(self.end_region.height * height)
+
+        regions = np.empty((n_frames, 4), dtype=np.int32)
+        for i in range(n_frames):
+            t = i / max(1, n_frames - 1)
+            et = self._ease(t)
+            crop_w = int(sw + (ew - sw) * et)
+            crop_h = int(sh + (eh - sh) * et)
+            x = max(0, min(int(sx + (ex - sx) * et), width - crop_w))
+            y = max(0, min(int(sy + (ey - sy) * et), height - crop_h))
+            regions[i] = (x, y, crop_w, crop_h)
+        return regions
+
+    def streaming_init(self, total_frames: int, fps: float, width: int, height: int) -> None:
+        self._stream_regions = self._precompute_regions(total_frames, width, height)
+        self._stream_target_w = width
+        self._stream_target_h = height
+
+    def process_frame(self, frame: np.ndarray, frame_index: int) -> np.ndarray:
+        idx = min(frame_index, len(self._stream_regions) - 1)
+        x, y, cw, ch = self._stream_regions[idx]
+        return self._crop_and_scale_frame(frame, x, y, cw, ch, self._stream_target_w, self._stream_target_h)
+
     def _apply(self, video: Video) -> Video:
         n_frames = len(video.frames)
         height, width = video.frame_shape[:2]
@@ -525,6 +633,8 @@ def _compute_curve(t: np.ndarray, curve: str) -> np.ndarray:
 class Fade(Effect):
     """Fades video and audio to or from black."""
 
+    supports_streaming: ClassVar[bool] = True
+
     def __init__(
         self,
         mode: Literal["in", "out", "in_out"],
@@ -549,6 +659,28 @@ class Fade(Effect):
         self.duration = duration
         self.curve = curve
 
+    def _compute_alpha(self, n_frames: int, fps: float) -> np.ndarray:
+        """Compute per-frame alpha values for the video fade."""
+        fade_frames = min(round(self.duration * fps), n_frames)
+        alpha = np.ones(n_frames, dtype=np.float32)
+        if self.mode in ("in", "in_out"):
+            t = np.linspace(0, 1, fade_frames, dtype=np.float32)
+            alpha[:fade_frames] = _compute_curve(t, self.curve)
+        if self.mode in ("out", "in_out"):
+            t = np.linspace(1, 0, fade_frames, dtype=np.float32)
+            alpha[-fade_frames:] = np.minimum(alpha[-fade_frames:], _compute_curve(t, self.curve))
+        return alpha
+
+    def streaming_init(self, total_frames: int, fps: float, width: int, height: int) -> None:
+        self._stream_alpha = self._compute_alpha(total_frames, fps)
+
+    def process_frame(self, frame: np.ndarray, frame_index: int) -> np.ndarray:
+        idx = min(frame_index, len(self._stream_alpha) - 1)
+        a = self._stream_alpha[idx]
+        if a == 1.0:
+            return frame
+        return (frame.astype(np.float32) * a).astype(np.uint8)
+
     def apply(self, video: Video, start: float | None = None, stop: float | None = None) -> Video:
         """Apply fade effect to video and audio.
 
@@ -569,16 +701,8 @@ class Fade(Effect):
         effect_start_frame = round(start_s * video.fps)
         effect_end_frame = round(stop_s * video.fps)
         n_effect_frames = effect_end_frame - effect_start_frame
-        fade_frames = min(round(self.duration * video.fps), n_effect_frames)
 
-        # Build per-frame alpha array (1.0 = fully visible, 0.0 = black)
-        alpha = np.ones(n_effect_frames, dtype=np.float32)
-        if self.mode in ("in", "in_out"):
-            t = np.linspace(0, 1, fade_frames, dtype=np.float32)
-            alpha[:fade_frames] = _compute_curve(t, self.curve)
-        if self.mode in ("out", "in_out"):
-            t = np.linspace(1, 0, fade_frames, dtype=np.float32)
-            alpha[-fade_frames:] = np.minimum(alpha[-fade_frames:], _compute_curve(t, self.curve))
+        alpha = self._compute_alpha(n_effect_frames, video.fps)
 
         # Apply to video frames in batches to avoid a full float32 copy
         batch_size = 64
@@ -600,29 +724,38 @@ class Fade(Effect):
 
         # Apply to audio
         if video.audio is not None and not video.audio.is_silent:
-            sample_rate = video.audio.metadata.sample_rate
-            audio_start = round(start_s * sample_rate)
-            audio_end = min(round(stop_s * sample_rate), len(video.audio.data))
-            n_audio_samples = audio_end - audio_start
-            fade_samples = min(round(self.duration * sample_rate), n_audio_samples)
-
-            audio_alpha = np.ones(n_audio_samples, dtype=np.float32)
-            if self.mode in ("in", "in_out"):
-                t = np.linspace(0, 1, fade_samples, dtype=np.float32)
-                audio_alpha[:fade_samples] = _compute_curve(t, self.curve)
-            if self.mode in ("out", "in_out"):
-                t = np.linspace(1, 0, fade_samples, dtype=np.float32)
-                audio_alpha[-fade_samples:] = np.minimum(audio_alpha[-fade_samples:], _compute_curve(t, self.curve))
-
-            audio_data = video.audio.data
-            if audio_data.ndim == 1:
-                audio_data[audio_start:audio_end] *= audio_alpha
-            else:
-                audio_data[audio_start:audio_end] *= audio_alpha[:, np.newaxis]
-            np.clip(audio_data, -1.0, 1.0, out=audio_data)
+            self.apply_audio(video.audio, start_s, stop_s)
 
         return video
 
+    def apply_audio(self, audio: Audio, start_s: float, stop_s: float) -> None:
+        """Apply fade to audio data in-place.
+
+        Args:
+            audio: Audio object to modify.
+            start_s: Start time in seconds.
+            stop_s: Stop time in seconds.
+        """
+        sample_rate = audio.metadata.sample_rate
+        audio_start = round(start_s * sample_rate)
+        audio_end = min(round(stop_s * sample_rate), len(audio.data))
+        n_samples = audio_end - audio_start
+        fade_samples = min(round(self.duration * sample_rate), n_samples)
+
+        alpha = np.ones(n_samples, dtype=np.float32)
+        if self.mode in ("in", "in_out"):
+            t = np.linspace(0, 1, fade_samples, dtype=np.float32)
+            alpha[:fade_samples] = _compute_curve(t, self.curve)
+        if self.mode in ("out", "in_out"):
+            t = np.linspace(1, 0, fade_samples, dtype=np.float32)
+            alpha[-fade_samples:] = np.minimum(alpha[-fade_samples:], _compute_curve(t, self.curve))
+
+        if audio.data.ndim == 1:
+            audio.data[audio_start:audio_end] *= alpha
+        else:
+            audio.data[audio_start:audio_end] *= alpha[:, np.newaxis]
+        np.clip(audio.data, -1.0, 1.0, out=audio.data)
+
     def _apply(self, video: Video) -> Video:
         raise NotImplementedError("Fade overrides apply() directly")
 
@@ -634,6 +767,11 @@ class AudioEffect(Effect):
     without modification. Overrides apply() to skip frame processing.
     """
 
+    supports_streaming: ClassVar[bool] = True
+
+    def process_frame(self, frame: np.ndarray, frame_index: int) -> np.ndarray:
+        return frame  # Audio effects don't touch frames
+
     def _apply(self, video: Video) -> Video:
         raise NotImplementedError("AudioEffect does not process frames -- use _apply_audio()")
 
@@ -717,6 +855,8 @@ class VolumeAdjust(AudioEffect):
 class TextOverlay(Effect):
     """Draws text on video frames, with auto word-wrap and optional background box."""
 
+    supports_streaming: ClassVar[bool] = True
+
     def __init__(
         self,
         text: str,
@@ -841,6 +981,37 @@ class TextOverlay(Effect):
             return px - img_w, py - img_h
         return px - img_w // 2, py - img_h // 2
 
+    def streaming_init(self, total_frames: int, fps: float, width: int, height: int) -> None:
+        if self._rendered is None:
+            self._rendered = self._render_text_image(width, height)
+        oh, ow = self._rendered.shape[:2]
+        x, y = self._compute_position(width, height, ow, oh)
+        src_x = max(0, -x)
+        src_y = max(0, -y)
+        dst_x = max(0, x)
+        dst_y = max(0, y)
+        paste_w = min(ow - src_x, width - dst_x)
+        paste_h = min(oh - src_y, height - dst_y)
+        if paste_w <= 0 or paste_h <= 0:
+            self._stream_noop = True
+            return
+        self._stream_noop = False
+        overlay_region = self._rendered[src_y : src_y + paste_h, src_x : src_x + paste_w]
+        self._stream_alpha = overlay_region[:, :, 3:4].astype(np.float32) / 255.0
+        self._stream_rgb = overlay_region[:, :, :3].astype(np.float32)
+        self._stream_dst = (dst_y, dst_x, paste_h, paste_w)
+
+    def process_frame(self, frame: np.ndarray, frame_index: int) -> np.ndarray:
+        if self._stream_noop:
+            return frame
+        dy, dx, ph, pw = self._stream_dst
+        region = frame[dy : dy + ph, dx : dx + pw]
+        blended = (
+            self._stream_rgb * self._stream_alpha + region.astype(np.float32) * (1.0 - self._stream_alpha)
+        ).astype(np.uint8)
+        frame[dy : dy + ph, dx : dx + pw] = blended
+        return frame
+
     def _apply(self, video: Video) -> Video:
         frame_h, frame_w = video.frame_shape[:2]
 

{videopython-0.25.8 → videopython-0.26.1}/src/videopython/base/registry.py

@@ -530,7 +530,7 @@ def _register_base_operations() -> None:
             Resize,
             op_id="resize",
             category=OperationCategory.TRANSFORMATION,
-            tags={"changes_dimensions"},
+            tags={"changes_dimensions", "streamable"},
             param_overrides={
                 "width": {"exclusive_minimum": 0},
                 "height": {"exclusive_minimum": 0},
@@ -543,7 +543,7 @@ def _register_base_operations() -> None:
             ResampleFPS,
             op_id="resample_fps",
             category=OperationCategory.TRANSFORMATION,
-            tags={"changes_fps"},
+            tags={"changes_fps", "streamable"},
             param_overrides={"fps": {"minimum": 1}},
             metadata_method="resample_fps",
         )
@@ -553,7 +553,7 @@ def _register_base_operations() -> None:
             Crop,
             op_id="crop",
             category=OperationCategory.TRANSFORMATION,
-            tags={"changes_dimensions"},
+            tags={"changes_dimensions", "streamable"},
             param_overrides={
                 "width": {"exclusive_minimum": 0},
                 "height": {"exclusive_minimum": 0},
@@ -634,6 +634,7 @@ def _register_base_operations() -> None:
             Blur,
             op_id="blur_effect",
             category=OperationCategory.EFFECT,
+            tags={"streamable"},
             aliases=("blur",),
             param_overrides={"iterations": {"minimum": 1}},
             apply_param_overrides=_time_range_apply_overrides,
@@ -644,6 +645,7 @@ def _register_base_operations() -> None:
             Zoom,
             op_id="zoom_effect",
             category=OperationCategory.EFFECT,
+            tags={"streamable"},
             aliases=("zoom",),
             param_overrides={"zoom_factor": {"exclusive_minimum": 1}},
             apply_param_overrides=_time_range_apply_overrides,
@@ -654,6 +656,7 @@ def _register_base_operations() -> None:
             ColorGrading,
             op_id="color_adjust",
             category=OperationCategory.EFFECT,
+            tags={"streamable"},
             aliases=("color_grading",),
             param_overrides={
                 "brightness": {"minimum": -1, "maximum": 1},
@@ -669,6 +672,7 @@ def _register_base_operations() -> None:
             Vignette,
             op_id="vignette",
             category=OperationCategory.EFFECT,
+            tags={"streamable"},
             param_overrides={
                 "strength": {"minimum": 0, "maximum": 1},
                 "radius": {"minimum": 0.5, "maximum": 2.0},
@@ -681,6 +685,7 @@ def _register_base_operations() -> None:
             KenBurns,
             op_id="ken_burns",
             category=OperationCategory.EFFECT,
+            tags={"streamable"},
             exclude_params={"start_region", "end_region"},
             # BoundingBox forward ref breaks get_type_hints, so fix easing type manually.
             param_overrides={
@@ -697,6 +702,7 @@ def _register_base_operations() -> None:
             FullImageOverlay,
             op_id="full_image_overlay",
             category=OperationCategory.EFFECT,
+            tags={"streamable"},
             exclude_params={"overlay_image"},
             param_overrides={
                 "alpha": {"minimum": 0, "maximum": 1},
@@ -710,6 +716,7 @@ def _register_base_operations() -> None:
             Fade,
             op_id="fade",
             category=OperationCategory.EFFECT,
+            tags={"streamable"},
             param_overrides={"duration": {"exclusive_minimum": 0}},
             apply_param_overrides=_time_range_apply_overrides,
         )
@@ -719,6 +726,7 @@ def _register_base_operations() -> None:
             VolumeAdjust,
             op_id="volume_adjust",
             category=OperationCategory.EFFECT,
+            tags={"streamable"},
             aliases=("volume",),
             param_overrides={
                 "volume": {"minimum": 0},
@@ -732,6 +740,7 @@ def _register_base_operations() -> None:
             TextOverlay,
             op_id="text_overlay",
             category=OperationCategory.EFFECT,
+            tags={"streamable"},
             aliases=("lower_third", "title_card"),
             exclude_params={"font_filename"},
             param_overrides={