videopython 0.46.0__tar.gz → 0.47.0__tar.gz

{videopython-0.46.0 → videopython-0.47.0}/PKG-INFO

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

{videopython-0.46.0 → videopython-0.47.0}/pyproject.toml

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

{videopython-0.46.0 → videopython-0.47.0}/src/videopython/ai/effects.py

@@ -9,7 +9,7 @@ AI-free renderer in :mod:`videopython.base.draw_detections`.
 
 from __future__ import annotations
 
-from typing import Any, ClassVar, Literal
+from typing import Any, Literal
 
 import numpy as np
 from pydantic import Field, PrivateAttr
@@ -39,7 +39,6 @@ class ObjectDetectionOverlay(Effect):
     """
 
     op: Literal["object_detection_overlay"] = "object_detection_overlay"
-    streamable: ClassVar[bool] = True
 
     confidence_threshold: float = Field(0.5, ge=0, le=1, description="Minimum detection confidence to draw a box, 0-1.")
     class_filter: list[str] | None = Field(

{videopython-0.46.0 → videopython-0.47.0}/src/videopython/ai/transforms.py

@@ -44,7 +44,6 @@ class FaceTrackingCrop(Operation):
 
     op: Literal["face_crop"] = "face_crop"
     category: ClassVar[OpCategory] = OpCategory.TRANSFORM
-    streamable: ClassVar[bool] = True
     compiles_from_source: ClassVar[bool] = True
 
     target_aspect: tuple[int, int] = Field((9, 16), description="Output aspect ratio as (width, height).")

{videopython-0.46.0 → videopython-0.47.0}/src/videopython/editing/effects.py

@@ -15,7 +15,6 @@ override :meth:`Effect.predict_metadata`. Anchored RGBA overlays
 from __future__ import annotations
 
 import logging
-import math
 import tempfile
 from io import BytesIO
 from pathlib import Path
@@ -73,7 +72,6 @@ class FullImageOverlay(Effect):
     """
 
     op: Literal["full_image_overlay"] = "full_image_overlay"
-    streamable: ClassVar[bool] = True
     llm_exposed: ClassVar[bool] = False
 
     source: Path = Field(
@@ -143,7 +141,6 @@ class Blur(Effect):
     """Applies Gaussian blur that can stay constant or ramp up/down over the clip."""
 
     op: Literal["blur_effect"] = "blur_effect"
-    streamable: ClassVar[bool] = True
 
     mode: Literal["constant", "ascending", "descending"] = Field(
         description=(
@@ -192,7 +189,6 @@ class Zoom(Effect):
     """Progressively zooms into or out of the frame center over the clip duration."""
 
     op: Literal["zoom_effect"] = "zoom_effect"
-    streamable: ClassVar[bool] = True
 
     zoom_factor: float = Field(
         gt=1,
@@ -228,47 +224,11 @@ class Zoom(Effect):
         cropped = frame[round(y) : round(y + h), round(x) : round(x + w)]
         return cv2.resize(cropped, (width, height))
 
-    @property
-    def compiles_to_filter(self) -> bool:
-        # Only an unwindowed, whole-clip zoom is a single comma-join-safe -vf
-        # entry. A windowed zoom (frames outside the window pass through) cannot
-        # be one zoompan, so it stays frame-only.
-        return self.window is None
-
-    def to_ffmpeg_filter(self, ctx: FilterCtx) -> str | None:
-        """Whole-clip center zoom via ffmpeg ``zoompan``.
-
-        Matches the numpy twin: the crop SIZE ramps linearly between the full
-        frame and ``width // zoom_factor`` and the frame is rescaled to the
-        original size, so the per-frame zoom is ``iw/crop_w``. The trailing
-        ``setpts=N/(fps*TB)`` is LOAD-BEARING: zoompan reinterprets PTS at its
-        own framerate, and without re-deriving PTS from the output frame number
-        the decode-stage ``fps=`` resampler multiplies the frame count. yuv-safe.
-        """
-        if ctx.frame_count <= 0:
-            return None
-        n = ctx.frame_count
-        w, h = ctx.width, ctx.height
-        small_w = w // self.zoom_factor
-        if self.mode == "out":
-            cw0, cw1 = float(small_w), float(w)
-        else:  # in
-            cw0, cw1 = float(w), float(small_w)
-        denom = max(n - 1, 1)
-        z_expr = f"iw/({cw0:.6f}+({cw1 - cw0:.6f})*on/{denom})"
-        return (
-            f"zoompan=z='{z_expr}'"
-            f":x='iw/2-iw/zoom/2':y='ih/2-ih/zoom/2'"
-            f":d=1:s={w}x{h}:fps={ctx.fps},setpts=N/({ctx.fps}*TB)"
-        )
-
 
 class ColorGrading(Effect):
     """Adjusts color properties: brightness, contrast, saturation, and temperature."""
 
     op: Literal["color_adjust"] = "color_adjust"
-    streamable: ClassVar[bool] = True
-    filter_needs_rgb24: ClassVar[bool] = True
 
     brightness: float = Field(
         0.0,
@@ -316,80 +276,11 @@ class ColorGrading(Effect):
     def process_frame(self, frame: np.ndarray, frame_index: int) -> np.ndarray:
         return self._grade_frame(frame)
 
-    @property
-    def _is_noop(self) -> bool:
-        return self.brightness == 0.0 and self.contrast == 1.0 and self.saturation == 1.0 and self.temperature == 0.0
-
-    def _channel_expr(self, src: str, temp_offset: float) -> str:
-        """Per-channel ``geq`` expression mirroring :meth:`_grade_frame`.
-
-        ``src`` is the geq accessor for the channel being computed
-        (``r(X,Y)``/``g(X,Y)``/``b(X,Y)``); ``temp_offset`` is the additive
-        temperature shift for this channel (``+t`` on red, ``0`` on green, ``-t``
-        on blue). The pipeline runs on normalised 0..1 values: brightness add,
-        contrast about 0.5 (unclipped, matching numpy), a cv2-equivalent HSV
-        "toward-max" saturation scale, the temperature shift, then a final clamp.
-        """
-        norm = {"r": "(r(X,Y)/255)", "g": "(g(X,Y)/255)", "b": "(b(X,Y)/255)"}
-
-        def bc(v: str) -> str:
-            return f"((({v}+{self.brightness:g})-0.5)*{self.contrast:g}+0.5)"
-
-        graded = bc(f"({src}/255)")
-        if self.saturation != 1.0:
-            # cv2 RGB->HSV scales saturation toward V=max(R,G,B), clipping S at 1:
-            # each channel C maps to V-(V-C)*ratio with ratio=min(sat, V/chroma).
-            # The HSV roundtrip clips inputs to 0..1 first.
-            rc = f"clip({bc(norm['r'])},0,1)"
-            gc = f"clip({bc(norm['g'])},0,1)"
-            bcl = f"clip({bc(norm['b'])},0,1)"
-            src_c = f"clip({graded},0,1)"
-            v = f"max(max({rc},{gc}),{bcl})"
-            mn = f"min(min({rc},{gc}),{bcl})"
-            chroma = f"({v}-{mn})"
-            ratio = f"if(gt({chroma},0),min({self.saturation:g},{v}/{chroma}),1)"
-            graded = f"({v}-({v}-{src_c})*({ratio}))"
-        if temp_offset != 0.0:
-            graded = f"({graded}+({temp_offset:g}))"
-        return f"clip(({graded})*255,0,255)"
-
-    def to_ffmpeg_filter(self, ctx: FilterCtx) -> str | None:
-        """Compile the colour grade to a single ``geq`` ``-vf`` entry.
-
-        Mirrors :meth:`_grade_frame` per channel (brightness, contrast,
-        cv2-equivalent HSV saturation, temperature) on normalised RGB, faithful
-        to the numpy path to within uint8 rounding (geq rounds; numpy truncates).
-        All commas live inside single-quoted per-channel expressions, so the
-        entry is comma-join safe. A no-op grade returns ``None``. ``self.window``
-        appends a timeline ``enable='between(t,start,stop)'``.
-        """
-        if self._is_noop:
-            return None
-        temp_shift = self.temperature * 0.1
-        r = self._channel_expr("r(X,Y)", temp_shift)
-        g = self._channel_expr("g(X,Y)", 0.0)
-        b = self._channel_expr("b(X,Y)", -temp_shift)
-        expr = f"geq=r='{r}':g='{g}':b='{b}'"
-        if self.window is not None:
-            stop = ctx.frame_count / ctx.fps if ctx.fps > 0 and ctx.frame_count > 0 else None
-            start_s = 0.0 if self.window.start is None else float(self.window.start)
-            stop_s = stop if self.window.stop is None else float(self.window.stop)
-            if stop_s is not None:
-                expr += f":enable='between(t,{start_s:g},{stop_s:g})'"
-        return expr
-
-    @property
-    def compiles_to_filter(self) -> bool:
-        """A no-op grade emits no filter; any active field compiles to one ``geq`` entry."""
-        return not self._is_noop
-
 
 class Vignette(Effect):
     """Darkens the edges of the frame, drawing attention to the center."""
 
     op: Literal["vignette"] = "vignette"
-    streamable: ClassVar[bool] = True
-    filter_needs_rgb24: ClassVar[bool] = True
 
     strength: float = Field(
         0.5,
@@ -427,38 +318,6 @@ class Vignette(Effect):
         assert self._stream_mask_3d is not None
         return (frame.astype(np.float32) * self._stream_mask_3d).astype(np.uint8)
 
-    @property
-    def compiles_to_filter(self) -> bool:
-        return True
-
-    def to_ffmpeg_filter(self, ctx: FilterCtx) -> str | None:
-        """Compile the radial darkening to a per-channel ``geq`` expression.
-
-        Reproduces :meth:`_create_mask` exactly in ffmpeg's expression language:
-        ``geq`` exposes per-pixel ``X``/``Y`` and the plane size ``W``/``H``, so
-        the normalized coordinates ``Xn = 2*X/(W-1) - 1`` / ``Yn = 2*Y/(H-1) - 1``
-        mirror ``np.linspace(-1, 1, ...)``, and the mask is
-        ``1 - clip(hypot(Xn, Yn)/radius - 0.5, 0, 1) * 2*strength`` applied to every
-        channel. ``clip`` is spelled with ``min``/``max`` and explicit products so
-        the expression carries no commas of its own -- only the quoted ``r(X,Y)``
-        lookups and the ``enable`` clause do, and those quotes survive the runner's
-        comma-join of the ``-vf`` chain. ``geq`` has native timeline support, so a
-        windowed vignette gates on ``enable`` and passes other frames through.
-        """
-        xn = "((2*X/(W-1))-1)"
-        yn = "((2*Y/(H-1))-1)"
-        falloff = 2.0 * self.strength
-        mask = f"(1-min(max(sqrt({xn}*{xn}+{yn}*{yn})/{self.radius:.6f}-0.5,0),1)*{falloff:.6f})"
-        r = f"r='r(X,Y)*{mask}'"
-        g = f"g='g(X,Y)*{mask}'"
-        b = f"b='b(X,Y)*{mask}'"
-        filt = f"geq={r}:{g}:{b}"
-        if self.window is not None:
-            start_s = 0.0 if self.window.start is None else float(self.window.start)
-            stop_s = ctx.frame_count / ctx.fps if self.window.stop is None else float(self.window.stop)
-            filt += f":enable='between(t,{start_s:.6f},{stop_s:.6f})'"
-        return filt
-
 
 class KenBurns(Effect):
     """Cinematic pan-and-zoom that smoothly animates between two crop regions.
@@ -469,7 +328,6 @@ class KenBurns(Effect):
     """
 
     op: Literal["ken_burns"] = "ken_burns"
-    streamable: ClassVar[bool] = True
 
     start_region: BoundingBox = Field(
         description="Starting crop region as a BoundingBox with normalized 0-1 coordinates."
@@ -549,7 +407,6 @@ class Fade(Effect):
     """Fades video and audio to or from black."""
 
     op: Literal["fade"] = "fade"
-    streamable: ClassVar[bool] = True
     audio_coupled: ClassVar[bool] = True
 
     mode: Literal["in", "out", "in_out"] = Field(
@@ -651,7 +508,6 @@ class VolumeAdjust(Effect):
     """Changes audio volume within a time range without affecting video frames."""
 
     op: Literal["volume_adjust"] = "volume_adjust"
-    streamable: ClassVar[bool] = True
     audio_coupled: ClassVar[bool] = True
 
     volume: float = Field(
@@ -828,7 +684,6 @@ class TextOverlay(_AnchoredOverlay):
     """Draws text on video frames, with auto word-wrap and optional background box."""
 
     op: Literal["text_overlay"] = "text_overlay"
-    streamable: ClassVar[bool] = True
 
     text: str = Field(min_length=1, description=r"The string to display. Use \n for line breaks.")
     position: tuple[float, float] = Field(
@@ -1036,7 +891,6 @@ class ImageOverlay(_AnchoredOverlay):
     """
 
     op: Literal["image_overlay"] = "image_overlay"
-    streamable: ClassVar[bool] = True
     llm_exposed: ClassVar[bool] = False
 
     source: Path = Field(
@@ -1158,7 +1012,6 @@ class Shake(Effect):
     """
 
     op: Literal["shake"] = "shake"
-    streamable: ClassVar[bool] = True
 
     intensity_px: float = Field(
         gt=0,
@@ -1224,7 +1077,6 @@ class PunchIn(Effect):
     """
 
     op: Literal["punch_in"] = "punch_in"
-    streamable: ClassVar[bool] = True
 
     zoom_factor: float = Field(
         gt=1.0,
@@ -1287,7 +1139,6 @@ class Flash(Effect):
     """
 
     op: Literal["flash"] = "flash"
-    streamable: ClassVar[bool] = True
 
     color: tuple[int, int, int] = Field(
         (255, 255, 255),
@@ -1351,8 +1202,6 @@ class ChromaticAberration(Effect):
     """
 
     op: Literal["chromatic_aberration"] = "chromatic_aberration"
-    streamable: ClassVar[bool] = True
-    filter_needs_rgb24: ClassVar[bool] = True
 
     shift_px: int = Field(
         gt=0,
@@ -1410,52 +1259,6 @@ class ChromaticAberration(Effect):
     def process_frame(self, frame: np.ndarray, frame_index: int) -> np.ndarray:
         return self._aberrate(frame)
 
-    def _enable_suffix(self, ctx: FilterCtx) -> str:
-        """``:enable='between(t,START,STOP)'`` for a windowed effect, else ``""``.
-
-        START defaults to 0.0 and STOP to the segment duration
-        (``ctx.frame_count / ctx.fps``); an unset window yields no suffix. The
-        clause is single-quoted, so its inner comma survives the runner's
-        ``",".join`` into the ``-vf`` chain.
-        """
-        if self.window is None:
-            return ""
-        total_seconds = ctx.frame_count / ctx.fps if ctx.fps > 0 and ctx.frame_count > 0 else 0.0
-        start_s = 0.0 if self.window.start is None else float(self.window.start)
-        stop_s = total_seconds if self.window.stop is None else float(self.window.stop)
-        return f":enable='between(t,{start_s:.6f},{stop_s:.6f})'"
-
-    def to_ffmpeg_filter(self, ctx: FilterCtx) -> str | None:
-        """Compile the channel split to a single native ``-vf`` entry.
-
-        ``horizontal``/``vertical`` become ``rgbashift`` (R by ``+shift_px``,
-        B by ``-shift_px`` along the axis, ``edge=smear`` == BORDER_REPLICATE).
-        ``radial`` becomes one ``geq`` sampling R/B from a scale about the frame
-        center (matches bilinear ``cv2.remap`` to ~4/255). Green is untouched.
-        Every inner comma sits inside single-quoted ``geq`` expressions or the
-        ``enable`` clause, so the entry is comma-join-safe.
-        """
-        enable = self._enable_suffix(ctx)
-        if self.mode == "horizontal":
-            return f"rgbashift=rh={self.shift_px}:bh={-self.shift_px}:edge=smear{enable}"
-        if self.mode == "vertical":
-            return f"rgbashift=rv={self.shift_px}:bv={-self.shift_px}:edge=smear{enable}"
-        # radial: reproduce the cv2.remap scale about the center via geq.
-        cx, cy = ctx.width / 2.0, ctx.height / 2.0
-        max_d = float(max(ctx.width, ctx.height))
-        scale_r = 1.0 - self.shift_px / max_d
-        scale_b = 1.0 + self.shift_px / max_d
-        rx = f"((X-{cx:.6f})*{scale_r:.9f}+{cx:.6f})"
-        ry = f"((Y-{cy:.6f})*{scale_r:.9f}+{cy:.6f})"
-        bx = f"((X-{cx:.6f})*{scale_b:.9f}+{cx:.6f})"
-        by = f"((Y-{cy:.6f})*{scale_b:.9f}+{cy:.6f})"
-        return f"geq=r='r({rx}\\,{ry})':b='b({bx}\\,{by})'{enable}"
-
-    @property
-    def compiles_to_filter(self) -> bool:
-        """Every mode compiles to a single, comma-join-safe ``-vf`` entry."""
-        return True
-
 
 class Glitch(Effect):
     """Random horizontal slice displacement + channel offsets for a digital-corruption look.
@@ -1466,7 +1269,6 @@ class Glitch(Effect):
     """
 
     op: Literal["glitch"] = "glitch"
-    streamable: ClassVar[bool] = True
 
     intensity: float = Field(
         0.5,
@@ -1528,7 +1330,6 @@ class FilmGrain(Effect):
     """
 
     op: Literal["film_grain"] = "film_grain"
-    streamable: ClassVar[bool] = True
 
     intensity: float = Field(
         0.1,
@@ -1558,31 +1359,6 @@ class FilmGrain(Effect):
     def process_frame(self, frame: np.ndarray, frame_index: int) -> np.ndarray:
         return self._grain_frame(frame, frame_index)
 
-    @property
-    def compiles_to_filter(self) -> bool:
-        # Only unwindowed monochrome (luma-only) grain compiles to a single
-        # comma-join-safe `noise` entry. The per-channel variant and any windowed
-        # grain stay on the numpy frame path.
-        return self.monochrome and self.window is None
-
-    def to_ffmpeg_filter(self, ctx: FilterCtx) -> str | None:
-        """Compile luma-only grain to ffmpeg's temporal ``noise`` filter.
-
-        A statistical (NOT pixel-identical) twin of :meth:`process_frame`:
-        ffmpeg's RNG differs from numpy's, so the grain is a different but
-        distributionally-matched draw -- equivalent in look for a random grain.
-        ``c0_flags=t`` adds fresh temporal noise to component 0 (Y in the
-        pipeline's yuv420p) each frame; ``c0_strength`` is ffmpeg's 0-100 scale,
-        which the numpy std (``intensity*255``) maps onto by the empirically-fit
-        ``strength = intensity * 255 / 0.57`` (clamped to [1, 100]) so the
-        injected per-pixel std matches in the real yuv pipeline. yuv-safe.
-        """
-        if not self.monochrome:
-            return None
-        strength = int(round(self.intensity * 255.0 / 0.57))
-        strength = max(1, min(100, strength))
-        return f"noise=c0_seed={self.seed}:c0_strength={strength}:c0_flags=t"
-
 
 class Sharpen(Effect):
     """Unsharp-mask sharpening: blur the frame and subtract from itself with weight.
@@ -1592,7 +1368,6 @@ class Sharpen(Effect):
     """
 
     op: Literal["sharpen"] = "sharpen"
-    streamable: ClassVar[bool] = True
 
     amount: float = Field(
         1.0,
@@ -1625,29 +1400,6 @@ class Sharpen(Effect):
     def process_frame(self, frame: np.ndarray, frame_index: int) -> np.ndarray:
         return self._sharpen_frame(frame)
 
-    @property
-    def compiles_to_filter(self) -> bool:
-        # The whole-frame, windowless case maps cleanly to a single comma-join
-        # safe `unsharp` -vf entry. A `window` would need an enable= gate that
-        # `unsharp` does not support, so windowed sharpening stays frame-only;
-        # `unsharp` also caps the combined matrix, so kernel_size > 13 stays too.
-        return self.window is None and self.kernel_size <= 13
-
-    def to_ffmpeg_filter(self, ctx: FilterCtx) -> str | None:
-        """Native unsharp-mask sharpening via ffmpeg's ``unsharp`` filter.
-
-        The numpy twin blends ``out = in + amount*(in - gaussian_blur(in))``.
-        ``unsharp=lx:ly:la`` is the same unsharp-mask form with the same
-        ``amount`` (``la``) weighting; its kernel is a box rather than a Gaussian,
-        so the result is a faithful visual twin (re-baseline-to-ffmpeg), not
-        bit-identical. ``amount == 0`` is a no-op (``None`` -> the runner keeps
-        the frame). ``unsharp`` is yuv-safe, so no ``format=rgb24`` is needed.
-        """
-        if self.amount == 0:
-            return None
-        k = self.kernel_size
-        return f"unsharp={k}:{k}:{self.amount:.6f}:{k}:{k}:{self.amount:.6f}"
-
 
 class Pixelate(Effect):
     """Mosaic blocks: downscale + nearest-neighbour upscale, optionally limited to a region.
@@ -1657,7 +1409,6 @@ class Pixelate(Effect):
     """
 
     op: Literal["pixelate"] = "pixelate"
-    streamable: ClassVar[bool] = True
 
     block_size: int = Field(
         gt=1,
@@ -1697,22 +1448,6 @@ class Pixelate(Effect):
         return self._pixelate_frame(frame, self._stream_region_px)
 
 
-def _mirror_geq(coord: str, src_x: str, src_y: str) -> str:
-    """One comma-join-safe ``geq`` entry that reflects a half-frame.
-
-    ``coord`` is the per-pixel predicate (e.g. ``gte(X,W/2)``); where it holds
-    the pixel samples its mirror ``(src_x, src_y)``, elsewhere it keeps
-    ``(X, Y)``. Per-channel (r/g/b) so geq runs in RGB. The function-call commas
-    live inside single-quoted plane expressions, so the whole entry survives
-    ``",".join`` into the ``-vf`` chain.
-    """
-
-    def plane(channel: str) -> str:
-        return f"if({coord},{channel}({src_x},{src_y}),{channel}(X,Y))"
-
-    return f"geq=r='{plane('r')}':g='{plane('g')}':b='{plane('b')}'"
-
-
 class MirrorFlip(Effect):
     """Flip frames or reflect one half onto the other.
 
@@ -1722,8 +1457,6 @@ class MirrorFlip(Effect):
     """
 
     op: Literal["mirror_flip"] = "mirror_flip"
-    streamable: ClassVar[bool] = True
-    filter_needs_rgb24: ClassVar[bool] = True
 
     mode: Literal[
         "horizontal",
@@ -1767,54 +1500,6 @@ class MirrorFlip(Effect):
     def process_frame(self, frame: np.ndarray, frame_index: int) -> np.ndarray:
         return self._flip_frame(frame)
 
-    def _enable_suffix(self, ctx: FilterCtx) -> str:
-        """``enable='between(t,START,STOP)'`` for the window, or '' when full-clip.
-
-        START defaults to 0.0 and STOP to the segment duration
-        (``ctx.frame_count / ctx.fps``). Returns the bare ``key=value`` (no
-        leading separator); the caller joins it with the right separator.
-        """
-        win = self.window
-        if win is None:
-            return ""
-        stop = ctx.frame_count / ctx.fps if win.stop is None else float(win.stop)
-        start = 0.0 if win.start is None else float(win.start)
-        return f"enable='between(t,{start:.6f},{stop:.6f})'"
-
-    def to_ffmpeg_filter(self, ctx: FilterCtx) -> str | None:
-        """Compile to one comma-join-safe ``-vf`` entry mirroring :meth:`process_frame`.
-
-        ``horizontal`` / ``vertical`` map to native ``hflip`` / ``vflip``
-        (bit-exact). The ``mirror_*`` modes reflect one half onto the other via a
-        single per-channel ``geq`` expression: each output pixel samples its
-        mirror (``W-1-X`` / ``H-1-Y``) on the reflected half and itself on the
-        kept half, matching the numpy ``w//2`` / ``h//2`` split for both even and
-        odd dimensions. A window appends an ``enable=`` option (``=`` for the
-        option-less flips, ``:`` after the ``geq`` options).
-        """
-        if self.mode == "horizontal":
-            base, sep = "hflip", "="
-        elif self.mode == "vertical":
-            base, sep = "vflip", "="
-        else:
-            sep = ":"
-            if self.mode == "mirror_left":
-                coord, src_x, src_y = "gte(X,W/2)", "W-1-X", "Y"
-            elif self.mode == "mirror_right":
-                coord, src_x, src_y = "lt(X,W/2)", "W-1-X", "Y"
-            elif self.mode == "mirror_top":
-                coord, src_x, src_y = "gte(Y,H/2)", "X", "H-1-Y"
-            else:  # mirror_bottom
-                coord, src_x, src_y = "lt(Y,H/2)", "X", "H-1-Y"
-            base = _mirror_geq(coord, src_x, src_y)
-
-        enable = self._enable_suffix(ctx)
-        return f"{base}{sep}{enable}" if enable else base
-
-    @property
-    def compiles_to_filter(self) -> bool:
-        return True
-
 
 class Kaleidoscope(Effect):
     """N-way radial mirror around the frame center.
@@ -1825,8 +1510,6 @@ class Kaleidoscope(Effect):
     """
 
     op: Literal["kaleidoscope"] = "kaleidoscope"
-    streamable: ClassVar[bool] = True
-    filter_needs_rgb24: ClassVar[bool] = True
 
     segments: int = Field(
         6,
@@ -1875,58 +1558,3 @@ class Kaleidoscope(Effect):
 
     def process_frame(self, frame: np.ndarray, frame_index: int) -> np.ndarray:
         return self._kaleidoscope_frame(frame)
-
-    def to_ffmpeg_filter(self, ctx: FilterCtx) -> str | None:
-        """Compile the radial mirror to a single per-pixel ``geq`` remap.
-
-        Mirrors :meth:`_build_maps`/:meth:`process_frame`. For each output pixel
-        ``geq`` recovers polar coordinates about ``((W-1)/2, (H-1)/2)``, folds
-        the angle into one wedge (``2*pi/segments``) the same way the numpy path
-        does (``mod`` then reflect across the half-wedge), and samples with
-        ``interpolation=bilinear``. Out-of-frame sample coordinates are reflected
-        back in-bounds (registers 8/9) to reproduce ``cv2.BORDER_REFLECT``. One
-        ``-vf`` node, comma-join-safe.
-        """
-        if ctx.width <= 0 or ctx.height <= 0:
-            return None
-        width, height = ctx.width, ctx.height
-        cx = (width - 1) / 2.0
-        cy = (height - 1) / 2.0
-        wedge = 2.0 * math.pi / self.segments
-        half = wedge * 0.5
-        pw = 2 * width
-        ph = 2 * height
-        ao = self.angle_offset
-
-        common = (
-            f"st(1,X-{cx:.8f});"
-            f"st(2,Y-{cy:.8f});"
-            f"st(3,hypot(ld(1),ld(2)));"
-            f"st(4,atan2(ld(2),ld(1))-{ao:.8f});"
-            f"st(5,mod(ld(4),{wedge:.10f}));"
-            f"st(5,if(lt(ld(5),0),ld(5)+{wedge:.10f},ld(5)));"
-            f"st(6,if(gt(ld(5),{half:.10f}),{wedge:.10f}-ld(5),ld(5)));"
-            f"st(7,ld(6)+{ao:.8f});"
-            f"st(8,mod({cx:.8f}+ld(3)*cos(ld(7)),{pw}));"
-            f"st(8,if(lt(ld(8),0),ld(8)+{pw},ld(8)));"
-            f"st(8,if(gte(ld(8),{width}),{pw - 1}-ld(8),ld(8)));"
-            f"st(9,mod({cy:.8f}+ld(3)*sin(ld(7)),{ph}));"
-            f"st(9,if(lt(ld(9),0),ld(9)+{ph},ld(9)));"
-            f"st(9,if(gte(ld(9),{height}),{ph - 1}-ld(9),ld(9)));"
-        )
-        expr = (
-            f"geq=interpolation=bilinear:"
-            f"r='{common}r(ld(8),ld(9))':"
-            f"g='{common}g(ld(8),ld(9))':"
-            f"b='{common}b(ld(8),ld(9))'"
-        )
-        if self.window is not None:
-            stop = ctx.frame_count / ctx.fps if ctx.fps > 0 and ctx.frame_count > 0 else 0.0
-            start_s = self.window.start if self.window.start is not None else 0.0
-            stop_s = self.window.stop if self.window.stop is not None else stop
-            expr += f":enable='between(t,{start_s:.6f},{stop_s:.6f})'"
-        return expr
-
-    @property
-    def compiles_to_filter(self) -> bool:
-        return True

{videopython-0.46.0 → videopython-0.47.0}/src/videopython/editing/operation.py

@@ -18,7 +18,6 @@ Subclass contract::
 
         op: Literal["resize"] = "resize"
         category: ClassVar[OpCategory] = OpCategory.TRANSFORM
-        streamable: ClassVar[bool] = True
 
         width: int | None = Field(None, gt=0)
         height: int | None = Field(None, gt=0)
@@ -234,8 +233,8 @@ class Operation(BaseModel):
 
     Concrete subclasses MUST declare an ``op`` field with a single-value
     ``Literal[str]`` annotation; that value is the discriminator on the JSON
-    wire and the registry key. Subclasses may override the ``category``,
-    ``streamable``, and ``requires`` ClassVars.
+    wire and the registry key. Subclasses may override the ``category`` and
+    ``requires`` ClassVars.
 
     ``predict_metadata`` defaults to identity; ``to_ffmpeg_filter`` defaults to
     ``None`` (no filter compilation).
@@ -246,7 +245,6 @@ class Operation(BaseModel):
     op: str
 
     category: ClassVar[OpCategory] = OpCategory.SPECIAL
-    streamable: ClassVar[bool] = False
     requires: ClassVar[tuple[str, ...]] = ()
     compiles_from_source: ClassVar[bool] = False
     """Whether the op's filter compile decodes the source itself (face_crop's
@@ -269,12 +267,11 @@ class Operation(BaseModel):
     """Whether this op is engine-internal and must NOT be a chain op.
 
     ``CutSeconds``/``CutFrames`` trim a segment, but trimming is the segment's own
-    ``start``/``end`` mechanism -- the engine constructs them directly. They are
-    non-streamable (no ffmpeg filter, no ``process_frame``), so to honor
-    "every registered op is streamable" they set this flag and are kept OUT of
-    the registry: they cannot appear in a plan's ``operations`` list or the LLM
+    ``start``/``end`` mechanism -- the engine constructs them directly. They have
+    no ffmpeg filter and no ``process_frame``, so this flag keeps them OUT of the
+    registry: they cannot appear in a plan's ``operations`` list or the LLM
     schema, while direct construction (``CutSeconds(start=..., end=...)``) still
-    works. Default False (a normal, streamable chain op)."""
+    works. Default False (a normal chain op)."""
     time_fields: ClassVar[tuple[BoundedTimeField, ...]] = ()
     """Time-valued (seconds) fields :meth:`VideoEdit.repair` may clamp into range.
 
@@ -449,6 +446,19 @@ class Operation(BaseModel):
         """
         return None
 
+    def streams(self) -> bool:
+        """Whether this op streams in O(1) memory at its plan position.
+
+        Structural replacement for the former ``streamable`` ClassVar: a transform
+        streams iff it overrides :meth:`to_ffmpeg_filter`. :class:`Effect` widens
+        this (a frame effect streams via ``process_frame``; a filter effect via
+        ``compiles_to_filter``). The one case structure cannot express -- the
+        override exists but the filter compiles to ``None`` at this position -- is
+        caught at runtime by the ``STREAMING_UNSUPPORTED`` raise in
+        ``VideoEdit._compile_streaming_plans``.
+        """
+        return type(self).to_ffmpeg_filter is not Operation.to_ffmpeg_filter
+
 
 class Effect(Operation):
     """Operation that preserves shape and frame count, driven by per-frame streaming.
@@ -470,17 +480,6 @@ class Effect(Operation):
     category: ClassVar[OpCategory] = OpCategory.EFFECT
     audio_coupled: ClassVar[bool] = False
     """Whether the effect mutates audio alongside pixels (``afade``/``volume``)."""
-    filter_needs_rgb24: ClassVar[bool] = False
-    """Whether :meth:`to_ffmpeg_filter` reads RGB pixel values and so needs the
-    decode chain converted to ``rgb24`` first.
-
-    ``geq``'s ``r``/``g``/``b`` accessors and ``rgbashift`` read RGB channels;
-    on the native yuv decode stream they read garbage. When a decode-stage
-    effect sets this, the plan builder prepends ``format=rgb24`` to the segment's
-    decode filter chain (encode-stage effects already receive rgb24 from the
-    frame pipe). Default False -- geometry/overlay filters (``hflip``,
-    ``subtitles=``) work in any pixel format. Mirrors the rgb24 frames the numpy
-    ``process_frame`` twin operated on."""
 
     window: TimeRange | None = Field(
         None,
@@ -527,3 +526,14 @@ class Effect(Operation):
         ``frame_index`` is 0-based within this effect's active window.
         """
         raise NotImplementedError(f"{type(self).__name__} does not support streaming")
+
+    def streams(self) -> bool:
+        """An effect streams via per-frame Python (``process_frame``) or a filter.
+
+        Frame effects override :meth:`process_frame`; filter effects
+        (``add_subtitles``, ``vignette``, ...) instead set
+        :attr:`compiles_to_filter` and implement :meth:`to_ffmpeg_filter`.
+        ``add_subtitles`` streams *only* via the filter path (it does not override
+        ``process_frame``), so ``compiles_to_filter`` is consulted per-instance.
+        """
+        return type(self).process_frame is not Effect.process_frame or self.compiles_to_filter

{videopython-0.46.0 → videopython-0.47.0}/src/videopython/editing/streaming.py

@@ -110,11 +110,12 @@ def _classify_op_list(ops: Sequence[Operation], location_prefix: str) -> list[Op
     ``location_prefix`` is the plan path entries are stamped under
     (``segments[i].operations`` or ``post_operations``).
 
-    ``streamable`` is the authoritative declaration (a flag-False transform
-    never streams, even with a working ``to_ffmpeg_filter``); the one divergence
-    the flag cannot express -- flag True but the filter compiles to ``None`` --
-    is caught at runtime by the ``STREAMING_UNSUPPORTED`` raise in
-    ``_compile_streaming_plans``. Purely structural: no disk access, no context.
+    A transform streams iff it overrides ``to_ffmpeg_filter`` and an effect iff it
+    overrides ``process_frame`` or sets ``compiles_to_filter`` (``op.streams()``);
+    the one divergence structure cannot express -- the override exists but the
+    filter compiles to ``None`` at this position -- is caught at runtime by the
+    ``STREAMING_UNSUPPORTED`` raise in ``_compile_streaming_plans``. Purely
+    structural: no disk access, no context.
     """
     entries: list[OpStreamability] = []
     seen_effect = False
@@ -123,7 +124,7 @@ def _classify_op_list(ops: Sequence[Operation], location_prefix: str) -> list[Op
     for j, op in enumerate(ops):
         location = f"{location_prefix}[{j}]"
         if isinstance(op, Effect):
-            if op.streamable and op.requires and seen_duration_change:
+            if op.requires and seen_duration_change:
                 # The builder rejects context-consuming ops behind a
                 # duration-changing transform: segment-local context is
                 # not re-mapped through the time warp yet.
@@ -140,7 +141,7 @@ def _classify_op_list(ops: Sequence[Operation], location_prefix: str) -> list[Op
                     )
                 )
                 continue
-            if op.streamable and op.compiles_to_filter:
+            if op.compiles_to_filter:
                 # Filter-class effect (add_subtitles, vignette, ...): joins the
                 # decode filter chain at this plan position -- or the encode
                 # chain when frame effects precede it -- so it streams in plan
@@ -150,13 +151,16 @@ def _classify_op_list(ops: Sequence[Operation], location_prefix: str) -> list[Op
                 if seen_effect:
                     seen_encode_stage = True
                 continue
-            if not op.streamable:
+            if not op.streams():
+                # Defensive: a custom Effect that overrides neither process_frame
+                # nor to_ffmpeg_filter (no built-in op does). compiles_to_filter
+                # was handled above, so this is "no process_frame".
                 entries.append(
                     OpStreamability(
                         location,
                         op.op,
                         StreamingClass.UNSTREAMABLE,
-                        reason="effect has no streaming implementation (streamable=False)",
+                        reason="effect has no streaming implementation (no process_frame or to_ffmpeg_filter)",
                     )
                 )
             elif seen_encode_stage:
@@ -189,7 +193,7 @@ def _classify_op_list(ops: Sequence[Operation], location_prefix: str) -> list[Op
                     ),
                 )
             )
-        elif op.requires and not op.streamable:
+        elif op.requires and not op.streams():
             entries.append(
                 OpStreamability(
                     location,
@@ -198,7 +202,7 @@ def _classify_op_list(ops: Sequence[Operation], location_prefix: str) -> list[Op
                     reason=(f"transform requires runtime context {sorted(op.requires)} and has no streaming strategy"),
                 )
             )
-        elif op.streamable and op.compiles_from_source and (seen_effect or seen_encode_stage):
+        elif op.streams() and op.compiles_from_source and (seen_effect or seen_encode_stage):
             entries.append(
                 OpStreamability(
                     location,
@@ -210,7 +214,7 @@ def _classify_op_list(ops: Sequence[Operation], location_prefix: str) -> list[Op
                     ),
                 )
             )
-        elif op.streamable:
+        elif op.streams():
             # Transforms compile to filters at any plan position: the decode
             # chain normally, the encode chain (after every process_frame) when
             # frame effects precede them.
@@ -269,22 +273,12 @@ class EffectScheduleEntry:
     re-based onto the segment-local timeline by the plan builder), forwarded
     as keyword arguments to ``streaming_init``. Empty for context-free
     effects.
-
-    For a post-operation folded across a multi-segment plan, the effect's
-    window lives on the assembled (concatenated) timeline: ``index_offset``
-    is the number of window frames consumed by previous segments (so
-    ``process_frame`` indices continue across the concat boundary) and
-    ``total_effect_frames`` is the global window length ``streaming_init``
-    must size envelopes to. Defaults describe the ordinary segment-local
-    case.
     """
 
     effect: Effect
     start_frame: int
     end_frame: int  # exclusive
     context: dict[str, Any] = field(default_factory=dict)
-    index_offset: int = 0
-    total_effect_frames: int | None = None
 
 
 @dataclass
@@ -751,9 +745,7 @@ def _stream_segment_framewise(
     # so a context-requiring effect with missing context fails before any
     # frame work on this segment.
     for entry in plan.effect_schedule:
-        n_effect_frames = (
-            entry.total_effect_frames if entry.total_effect_frames is not None else entry.end_frame - entry.start_frame
-        )
+        n_effect_frames = entry.end_frame - entry.start_frame
         entry.effect.streaming_init(
             n_effect_frames, plan.output_fps, plan.output_width, plan.output_height, **entry.context
         )
@@ -794,7 +786,7 @@ def _stream_segment_framewise(
                         # sized to the estimate stay in bounds.
                         open_ended = entry.end_frame >= total_frames
                         if entry.start_frame <= frame_count and (frame_count < entry.end_frame or open_ended):
-                            local_index = entry.index_offset + min(frame_count, entry.end_frame - 1) - entry.start_frame
+                            local_index = min(frame_count, entry.end_frame - 1) - entry.start_frame
                             frame = entry.effect.process_frame(frame, local_index)
 
                     encoder.write_frame(frame)

{videopython-0.46.0 → videopython-0.47.0}/src/videopython/editing/transcription_overlay.py

@@ -107,7 +107,6 @@ class TranscriptionOverlay(Effect):
     """
 
     op: Literal["add_subtitles"] = "add_subtitles"
-    streamable: ClassVar[bool] = True
     requires: ClassVar[tuple[str, ...]] = ("transcription",)
 
     # ---- primary, resolution-independent surface ----

{videopython-0.46.0 → videopython-0.47.0}/src/videopython/editing/transforms.py

@@ -146,7 +146,6 @@ class Resize(Operation):
 
     op: Literal["resize"] = "resize"
     category: ClassVar[OpCategory] = OpCategory.TRANSFORM
-    streamable: ClassVar[bool] = True
 
     width: int | None = Field(None, gt=0, description="Target width in pixels, or None to maintain aspect ratio.")
     height: int | None = Field(None, gt=0, description="Target height in pixels, or None to maintain aspect ratio.")
@@ -187,7 +186,6 @@ class ResampleFPS(Operation):
 
     op: Literal["resample_fps"] = "resample_fps"
     category: ClassVar[OpCategory] = OpCategory.TRANSFORM
-    streamable: ClassVar[bool] = True
 
     fps: float = Field(gt=0, description="Target frames per second.")
 
@@ -212,7 +210,6 @@ class Crop(Operation):
 
     op: Literal["crop"] = "crop"
     category: ClassVar[OpCategory] = OpCategory.TRANSFORM
-    streamable: ClassVar[bool] = True
 
     width: int | float = Field(description="Crop width in pixels (int) or fraction in (0, 1] of source width.")
     height: int | float = Field(description="Crop height in pixels (int) or fraction in (0, 1] of source height.")
@@ -280,7 +277,6 @@ class SpeedChange(Operation):
 
     op: Literal["speed_change"] = "speed_change"
     category: ClassVar[OpCategory] = OpCategory.TRANSFORM
-    streamable: ClassVar[bool] = True
     changes_duration: ClassVar[bool] = True
 
     speed: float = Field(gt=0, description="Playback speed multiplier. 2.0 = twice as fast, 0.5 = half speed.")
@@ -385,7 +381,6 @@ class FreezeFrame(Operation):
 
     op: Literal["freeze_frame"] = "freeze_frame"
     category: ClassVar[OpCategory] = OpCategory.TRANSFORM
-    streamable: ClassVar[bool] = True
     changes_duration: ClassVar[bool] = True
     # `timestamp` indexes a frame, so it must be strictly < the clip duration;
     # repair clamps an out-of-range value to the last frame.
@@ -510,7 +505,6 @@ class SilenceRemoval(Operation):
 
     op: Literal["silence_removal"] = "silence_removal"
     category: ClassVar[OpCategory] = OpCategory.TRANSFORM
-    streamable: ClassVar[bool] = True
     changes_duration: ClassVar[bool] = True
     requires: ClassVar[tuple[str, ...]] = ("transcription",)
 

{videopython-0.46.0 → videopython-0.47.0}/src/videopython/editing/video_edit.py

@@ -1954,9 +1954,9 @@ class VideoEdit(BaseModel):
 
         The single admission point for :meth:`run_to_file`. Unstreamable shapes raise
         :class:`PlanValidationError` with the streamability report's
-        structured errors; a builder/report drift (e.g. a third-party
-        transform whose ``streamable`` flag does not match its
-        ``to_ffmpeg_filter``) raises with a generic ``STREAMING_UNSUPPORTED``.
+        structured errors; a builder/report drift (e.g. an op whose
+        ``to_ffmpeg_filter`` returns ``None`` at its plan position despite
+        overriding it) raises with a generic ``STREAMING_UNSUPPORTED``.
         On raise, any compile-time temp files already created are deleted;
         on success the caller owns ``plan.owned_temp_files``.
         """
@@ -2073,7 +2073,6 @@ class VideoEdit(BaseModel):
         post_af_filters: list[str] = []
         audio_idx = 0
         duration_changed = False
-        decode_needs_rgb = False
 
         def compile_audio_twin(op: Operation, ctx: FilterCtx, encode_stage: bool) -> None:
             """Append the op's audio-domain filter at the same stage the video
@@ -2100,7 +2099,7 @@ class VideoEdit(BaseModel):
         try:
             for op in segment.operations:
                 if isinstance(op, Effect):
-                    if not op.streamable:
+                    if not op.streams():
                         abandon()
                         return None
                     if op.requires and duration_changed:
@@ -2129,7 +2128,6 @@ class VideoEdit(BaseModel):
                                 post_vf_filters.append(filter_expr)
                             else:
                                 vf_filters.append(filter_expr)
-                                decode_needs_rgb = decode_needs_rgb or op.filter_needs_rgb24
                             # Audio twin at the same stage (add_subtitles has
                             # none today; kept coupled for extensibility).
                             compile_audio_twin(op, ctx, encode_stage_effect)
@@ -2155,7 +2153,7 @@ class VideoEdit(BaseModel):
                     effect_ctx = make_ctx()
                     compile_audio_twin(op, effect_ctx, encode_stage=False)
                     continue
-                if op.requires and (duration_changed or not op.streamable):
+                if op.requires and (duration_changed or not op.streams()):
                     # A context-requiring transform can stream only when its
                     # filter compile can consume the context (silence_removal
                     # does, via FilterCtx.context) -- but not after a
@@ -2165,15 +2163,13 @@ class VideoEdit(BaseModel):
                     # streamability report.
                     abandon()
                     return None
-                # Non-effect transform: compile to ffmpeg filter if streamable.
-                # The `streamable` flag is the authoritative declaration -- checked
-                # first so the streamability report (which classifies by the flag)
-                # can never disagree with the builder in this direction: a
-                # flag-False transform is classified UNSTREAMABLE even if it has
-                # a working to_ffmpeg_filter. The remaining drift class (flag
-                # True, filter compiles to None) is caught by the
-                # STREAMING_UNSUPPORTED raise in _compile_streaming_plans.
-                if not op.streamable:
+                # Non-effect transform: streams iff it compiles a filter. Checked
+                # structurally (op.streams() == overrides to_ffmpeg_filter) so the
+                # streamability report and the builder cannot disagree; the
+                # remaining drift class (overrides to_ffmpeg_filter but it compiles
+                # to None here) is caught by the STREAMING_UNSUPPORTED raise in
+                # _compile_streaming_plans.
+                if not op.streams():
                     abandon()
                     return None
                 encode_stage = bool(effect_schedule or post_vf_filters)
@@ -2213,14 +2209,6 @@ class VideoEdit(BaseModel):
             abandon()
             raise
 
-        # A decode-stage filter-effect that reads RGB (geq r/g/b, rgbashift)
-        # must see rgb24, not the native yuv decode stream; prepend one
-        # conversion ahead of the whole decode chain (encode-stage effects
-        # already receive rgb24 from the frame pipe). Idempotent: only when an
-        # rgb-reading effect landed at decode and no conversion leads already.
-        if decode_needs_rgb and not (vf_filters and vf_filters[0] == "format=rgb24"):
-            vf_filters.insert(0, "format=rgb24")
-
         pipe = pipe_meta or running
         # Final output duration after every transform (decode + encode stage),
         # used to pin the audio graph length to the video timeline. `running`