videopython 0.1.2__tar.gz → 0.1.4__tar.gz

{videopython-0.1.2 → videopython-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: videopython
-Version: 0.1.2
+Version: 0.1.4
 Summary: Minimal video generation and processing library.
 Author-email: Bartosz Wójtowicz <bartoszwojtowicz@outlook.com>, Bartosz Rudnikowicz <bartoszrudnikowicz840@gmail.com>, Piotr Pukisz <piotr.pukisz@gmail.com>
 License:                                  Apache License
@@ -199,7 +199,7 @@ License:                                  Apache License
 Project-URL: Homepage, https://github.com/bartwojtowicz/videopython/
 Project-URL: Bug Reports, https://github.com/bartwojtowicz/videopython/issues
 Project-URL: Source, https://github.com/bartwojtowicz/videopython/
-Keywords: videopython,video,movie,opencv,generation,editing
+Keywords: python,videopython,video,movie,opencv,generation,editing
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
@@ -210,14 +210,23 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: click>=8.1.7
 Requires-Dist: numpy>=1.25.2
-Requires-Dist: opencv-python>=4.7.0.68
-Requires-Dist: pytest>=7.4.0
-Requires-Dist: transformers>=4.36.0
-Requires-Dist: diffusers>=0.21.4
-Requires-Dist: torch>=2.1.0
-Requires-Dist: stability-sdk>=0.8.4
-Requires-Dist: openai==1.3.5
+Requires-Dist: opencv-python>=4.9.0.80
+Requires-Dist: pillow>=10.3.0
 Requires-Dist: pydub>=0.25.1
+Requires-Dist: tqdm>=4.66.3
+Provides-Extra: dev
+Requires-Dist: black==24.3.0; extra == "dev"
+Requires-Dist: isort==5.12.0; extra == "dev"
+Requires-Dist: mypy==1.8.0; extra == "dev"
+Requires-Dist: pytest==7.4.0; extra == "dev"
+Requires-Dist: types-Pillow==10.2.0.20240213; extra == "dev"
+Requires-Dist: types-tqdm==4.66.0.20240106; extra == "dev"
+Requires-Dist: pydub-stubs==0.25.1.1; extra == "dev"
+Provides-Extra: generation
+Requires-Dist: accelerate>=0.29.2; extra == "generation"
+Requires-Dist: diffusers>=0.26.3; extra == "generation"
+Requires-Dist: torch>=2.1.0; extra == "generation"
+Requires-Dist: transformers>=4.38.1; extra == "generation"
 
 # About
 
@@ -235,41 +244,40 @@ sudo apt-get install ffmpeg
 
 ### Install with pip
 ```bash
-pip install videopython
+pip install videopython[generation]
 ```
+> You can install without `[generation]` dependencies for basic video handling and processing. 
+> The funcionalities found in `videopython.generation` won't work.
 
 ## Basic Usage
+> Using Nvidia A40 or better is recommended for the `videopython.generation` module.
 
 ```python
-from videopython.base.video import Video
-from videopython.base.transitions import FadeTransition
+# Generate image and animate it
+from videopython.generation import ImageToVideo
+from videopython.generation import TextToImage
 
-# Load video
-video = Video.from_path("tests/test_data/fast_benchmark.mp4")
-print(video.metadata)
-print(video.frames.shape) # Video is based on numpy representation of frames
+image = TextToImage().generate_image(prompt="Golden Retriever playing in the park")
+video = ImageToVideo().generate_video(image=image, fps=24)
 
-# Generate videos
-video1 = Video.from_prompt("Dogs playing in the snow.")
-video2 = Video.from_prompt("Dogs going back home.")
+# Video generation directly from prompt
+from videopython.generation import TextToVideo
+video_gen = TextToVideo()
+video = video_gen.generate_video("Dogs playing in the snow")
+for _ in range(10):
+    video += video_gen.generate_video("Dogs playing in the snow")
 
-# Add videos
-combined_video = video1 + video2
-print(combined_video.metadata)
+# Cut the first 2 seconds
+from videopython.base.transforms import CutSeconds
+transformed_video = CutSeconds(start_second=0, end_second=2).apply(video.copy())
 
-# Apply fade transition between videos
-fade = FadeTransition(0.5) # 0.5s effect time
-faded_video = fade.apply(videos=(video1, video2))
-print(faded_video.metadata)
+# Upsample to 30 FPS
+from videopython.base.transforms import ResampleFPS
+transformed_video = ResampleFPS(new_fps=30).apply(transformed_video)
 
-# Add audio from file
-faded_video.add_audio_from_file("tests/test_data/test_audio.mp3")
+# Resize to 1000x1000
+from videopython.base.transforms import Resize
+transformed_video = Resize(width=1000, height=1000).apply(transformed_video)
 
-# Save to a file
-faded_video.save("my_video.mp4")
-```
-
-### Running Unit Tests
-```bash
-PYTHONPATH=./src/ pytest
+filepath = transformed_video.save()
 ```

videopython-0.1.4/README.md

@@ -0,0 +1,53 @@
+# About
+
+Minimal video generation and processing library.
+
+## Setup 
+
+### Install ffmpeg
+```bash
+# Install with brew for MacOS:
+brew install ffmpeg
+# Install with apt-get for Ubuntu:
+sudo apt-get install ffmpeg
+```
+
+### Install with pip
+```bash
+pip install videopython[generation]
+```
+> You can install without `[generation]` dependencies for basic video handling and processing. 
+> The funcionalities found in `videopython.generation` won't work.
+
+## Basic Usage
+> Using Nvidia A40 or better is recommended for the `videopython.generation` module.
+
+```python
+# Generate image and animate it
+from videopython.generation import ImageToVideo
+from videopython.generation import TextToImage
+
+image = TextToImage().generate_image(prompt="Golden Retriever playing in the park")
+video = ImageToVideo().generate_video(image=image, fps=24)
+
+# Video generation directly from prompt
+from videopython.generation import TextToVideo
+video_gen = TextToVideo()
+video = video_gen.generate_video("Dogs playing in the snow")
+for _ in range(10):
+    video += video_gen.generate_video("Dogs playing in the snow")
+
+# Cut the first 2 seconds
+from videopython.base.transforms import CutSeconds
+transformed_video = CutSeconds(start_second=0, end_second=2).apply(video.copy())
+
+# Upsample to 30 FPS
+from videopython.base.transforms import ResampleFPS
+transformed_video = ResampleFPS(new_fps=30).apply(transformed_video)
+
+# Resize to 1000x1000
+from videopython.base.transforms import Resize
+transformed_video = Resize(width=1000, height=1000).apply(transformed_video)
+
+filepath = transformed_video.save()
+```

{videopython-0.1.2 → videopython-0.1.4}/pyproject.toml

@@ -1,15 +1,23 @@
 [build-system]
-requires = ["setuptools>=61.0"]
+requires = ["setuptools>=66.1"]
 build-backend = "setuptools.build_meta"
 
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["videopython.*"]
+
+[tool.setuptools.package-data]
+"videopython" = ["py.typed"]
+
 [project]
 name = "videopython"
-version = "0.1.2"
+version = "0.1.4"
 description = "Minimal video generation and processing library."
 readme = "README.md"
 requires-python = ">=3.10"
 license = {file = "LICENSE"}
-keywords = ["videopython", "video", "movie", "opencv", "generation", "editing"]
+keywords = ["python", "videopython", "video", "movie", "opencv", "generation", "editing"]
+dynamic = ["dependencies", "optional-dependencies"]
 
 authors = [
   {name = "Bartosz Wójtowicz", email = "bartoszwojtowicz@outlook.com" },
@@ -25,20 +33,11 @@ classifiers = [
   "Operating System :: OS Independent",
 ]
 
-dependencies = [
-    "click>=8.1.7",
-    "numpy>=1.25.2",
-    "opencv-python>=4.7.0.68",
-    "pytest>=7.4.0",
-    "transformers>=4.36.0",
-    "diffusers>=0.21.4",
-    "torch>=2.1.0",
-    "stability-sdk>=0.8.4",
-    "openai==1.3.5",
-    "pydub>=0.25.1"
-]
+[tool.setuptools.dynamic]
+dependencies = {file = ["requirements.txt"]}
+optional-dependencies = { dev = {file = ["requirements-dev.txt"]}, generation = {file = ["requirements-generation.txt"]} }
 
-[project.urls]  # Optional
+[project.urls]
 "Homepage" = "https://github.com/bartwojtowicz/videopython/"
 "Bug Reports" = "https://github.com/bartwojtowicz/videopython/issues"
 "Source" = "https://github.com/bartwojtowicz/videopython/"

videopython-0.1.4/requirements-dev.txt

@@ -0,0 +1,7 @@
+black==24.3.0
+isort==5.12.0
+mypy==1.8.0
+pytest==7.4.0
+types-Pillow==10.2.0.20240213
+types-tqdm==4.66.0.20240106
+pydub-stubs==0.25.1.1

videopython-0.1.4/requirements-generation.txt

@@ -0,0 +1,4 @@
+accelerate>=0.29.2
+diffusers>=0.26.3
+torch>=2.1.0
+transformers>=4.38.1

videopython-0.1.4/requirements.txt

@@ -0,0 +1,6 @@
+click>=8.1.7
+numpy>=1.25.2
+opencv-python>=4.9.0.80
+pillow>=10.3.0
+pydub>=0.25.1
+tqdm>=4.66.3

videopython-0.1.4/src/videopython/base/effects.py

@@ -0,0 +1,183 @@
+from abc import ABC, abstractmethod
+from typing import Literal, final
+
+import cv2
+import numpy as np
+from PIL import Image
+from tqdm import tqdm
+
+from videopython.base.video import Video
+
+
+class Effect(ABC):
+    """Abstract class for effect on frames of video.
+
+    The effect must not change the number of frames and the shape of the frames.
+    """
+
+    @final
+    def apply(self, video: Video, start: float | None = None, stop: float | None = None) -> Video:
+        original_shape = video.video_shape
+        start = start if start is not None else 0
+        stop = stop if stop is not None else video.total_seconds
+        # Check for start and stop correctness
+        if not 0 <= start <= video.total_seconds:
+            raise ValueError(f"Video is only {video.total_seconds} long, but passed start: {start}!")
+        elif not start <= stop <= video.total_seconds:
+            raise ValueError(f"Video is only {video.total_seconds} long, but passed stop: {stop}!")
+        # Apply effect on video slice
+        effect_start_frame = round(start * video.fps)
+        effect_end_frame = round(stop * video.fps)
+        video_with_effect = self._apply(video[effect_start_frame:effect_end_frame])
+        old_audio = video.audio
+        video = Video.from_frames(
+            np.r_[
+                "0,2",
+                video.frames[:effect_start_frame],
+                video_with_effect.frames,
+                video.frames[effect_end_frame:],
+            ],
+            fps=video.fps,
+        )
+        video.audio = old_audio
+        # Check if dimensions didn't change
+        if not video.video_shape == original_shape:
+            raise RuntimeError("The effect must not change the number of frames and the shape of the frames!")
+
+        return video
+
+    @abstractmethod
+    def _apply(self, video: Video) -> Video:
+        pass
+
+
+class FullImageOverlay(Effect):
+    def __init__(self, overlay_image: np.ndarray, alpha: float | None = None, fade_time: float = 0.0):
+        if alpha is not None and not 0 <= alpha <= 1:
+            raise ValueError("Alpha must be in range [0, 1]!")
+        elif not (overlay_image.ndim == 3 and overlay_image.shape[-1] in [3, 4]):
+            raise ValueError("Only RGB and RGBA images are supported as an overlay!")
+        elif alpha is None:
+            alpha = 1.0
+
+        if overlay_image.shape[-1] == 3:
+            overlay_image = np.dstack([overlay_image, np.full(overlay_image.shape[:2], 255, dtype=np.uint8)])
+
+        self.alpha = alpha
+        self.overlay = overlay_image.astype(np.uint8)
+        self.fade_time = fade_time
+
+    def _overlay(self, img: np.ndarray, alpha: float = 1.0) -> np.ndarray:
+        img_pil = Image.fromarray(img)
+        overlay = self.overlay.copy()
+        overlay[:, :, 3] = overlay[:, :, 3] * (self.alpha * alpha)
+        overlay_pil = Image.fromarray(overlay)
+        img_pil.paste(overlay_pil, (0, 0), overlay_pil)
+        return np.array(img_pil)
+
+    def _apply(self, video: Video) -> Video:
+        if not video.frame_shape == self.overlay[:, :, :3].shape:
+            raise ValueError(
+                f"Mismatch of overlay shape `{self.overlay.shape}` with video shape: `{video.frame_shape}`!"
+            )
+        elif not (0 <= 2 * self.fade_time <= video.total_seconds):
+            raise ValueError(f"Video is only {video.total_seconds}s long, but fade time is {self.fade_time}s!")
+
+        print("Overlaying video...")
+        if self.fade_time == 0:
+            video.frames = np.array([self._overlay(frame) for frame in tqdm(video.frames)], dtype=np.uint8)
+        else:
+            num_video_frames = len(video.frames)
+            num_fade_frames = round(self.fade_time * video.fps)
+            new_frames = []
+            for i, frame in enumerate(tqdm(video.frames)):
+                frames_dist_from_end = min(i, num_video_frames - i)
+                if frames_dist_from_end >= num_fade_frames:
+                    fade_alpha = 1.0
+                else:
+                    fade_alpha = frames_dist_from_end / num_fade_frames
+                new_frames.append(self._overlay(frame, fade_alpha))
+            video.frames = np.array(new_frames, dtype=np.uint8)
+        return video
+
+
+class Blur(Effect):
+    def __init__(
+        self,
+        mode: Literal["constant", "ascending", "descending"],
+        iterations: int,
+        kernel_size: tuple[int, int] = (5, 5),
+    ):
+        if iterations < 1:
+            raise ValueError("Iterations must be at least 1!")
+        self.mode = mode
+        self.iterations = iterations
+        self.kernel_size = kernel_size
+
+    def _apply(self, video: Video) -> Video:
+        n_frames = len(video.frames)
+        new_frames = []
+        if self.mode == "constant":
+            for frame in video.frames:
+                blurred_frame = frame
+                for _ in range(self.iterations):
+                    blurred_frame = cv2.GaussianBlur(blurred_frame, self.kernel_size, 0)
+                new_frames.append(blurred_frame)
+        elif self.mode == "ascending":
+            for i, frame in tqdm(enumerate(video.frames)):
+                frame_iterations = max(1, round((i / n_frames) * self.iterations))
+                blurred_frame = frame
+                for _ in range(frame_iterations):
+                    blurred_frame = cv2.GaussianBlur(blurred_frame, self.kernel_size, 0)
+                new_frames.append(blurred_frame)
+        elif self.mode == "descending":
+            for i, frame in tqdm(enumerate(video.frames)):
+                frame_iterations = max(round(((n_frames - i) / n_frames) * self.iterations), 1)
+                blurred_frame = frame
+                for _ in range(frame_iterations):
+                    blurred_frame = cv2.GaussianBlur(blurred_frame, self.kernel_size, 0)
+                new_frames.append(blurred_frame)
+        else:
+            raise ValueError(f"Unknown mode: `{self.mode}`.")
+        video.frames = np.asarray(new_frames)
+        return video
+
+
+class Zoom(Effect):
+    def __init__(self, zoom_factor: float, mode: Literal["in", "out"]):
+        if zoom_factor <= 1:
+            raise ValueError("Zoom factor must be greater than 1!")
+        self.zoom_factor = zoom_factor
+        self.mode = mode
+
+    def _apply(self, video: Video) -> Video:
+        n_frames = len(video.frames)
+        new_frames = []
+
+        width = video.metadata.width
+        height = video.metadata.height
+        crop_sizes_w, crop_sizes_h = np.linspace(width // self.zoom_factor, width, n_frames), np.linspace(
+            height // self.zoom_factor, height, n_frames
+        )
+
+        if self.mode == "in":
+            for frame, w, h in tqdm(zip(video.frames, reversed(crop_sizes_w), reversed(crop_sizes_h))):
+
+                x = width / 2 - w / 2
+                y = height / 2 - h / 2
+
+                cropped_frame = frame[round(y) : round(y + h), round(x) : round(x + w)]
+                zoomed_frame = cv2.resize(cropped_frame, (width, height))
+                new_frames.append(zoomed_frame)
+        elif self.mode == "out":
+            for frame, w, h in tqdm(zip(video.frames, crop_sizes_w, crop_sizes_h)):
+                x = width / 2 - w / 2
+                y = height / 2 - h / 2
+
+                cropped_frame = frame[round(y) : round(y + h), round(x) : round(x + w)]
+                zoomed_frame = cv2.resize(cropped_frame, (width, height))
+                new_frames.append(zoomed_frame)
+        else:
+            raise ValueError(f"Unknown mode: `{self.mode}`.")
+        video.frames = np.asarray(new_frames)
+        return video

videopython-0.1.4/src/videopython/base/transforms.py

@@ -0,0 +1,178 @@
+from abc import ABC, abstractmethod
+from enum import Enum
+from multiprocessing import Pool
+from typing import Literal
+
+import cv2
+import numpy as np
+from tqdm import tqdm
+
+from videopython.base.video import Video
+
+
+class Transformation(ABC):
+    """Abstract class for transformation on frames of video."""
+
+    @abstractmethod
+    def apply(self, video: Video) -> Video:
+        pass
+
+
+class TransformationPipeline:
+    def __init__(self, transformations: list[Transformation] | None):
+        """Initializes pipeline."""
+        self.transformations = transformations if transformations else []
+
+    def add(self, transformation: Transformation):
+        """Adds transformation to the pipeline.
+
+        Args:
+            transformation: Transformation to add.
+
+        Returns:
+            Pipeline with added transformation.
+        """
+        self.transformations.append(transformation)
+        return self
+
+    def run(self, video: Video) -> Video:
+        """Applies pipeline to the video.
+
+        Args:
+            video: Video to transform.
+
+        Returns:
+            Transformed video.
+        """
+        for transformation in self.transformations:
+            video = transformation.apply(video)
+        return video
+
+    def __call__(self, video: Video) -> Video:
+        return self.run(video)
+
+
+class CutFrames(Transformation):
+    def __init__(self, start_frame: int, end_frame: int):
+        self.start_frame = start_frame
+        self.end_frame = end_frame
+
+    def apply(self, video: Video) -> Video:
+        video = video[self.start_frame : self.end_frame]
+        return video
+
+
+class CutSeconds(Transformation):
+    def __init__(self, start_second: float | int, end_second: float | int):
+        self.start_second = start_second
+        self.end_second = end_second
+
+    def apply(self, video: Video) -> Video:
+        video = video[round(self.start_second * video.fps) : round(self.end_second * video.fps)]
+        return video
+
+
+class Resize(Transformation):
+    def __init__(self, width: int | None = None, height: int | None = None):
+        self.width = width
+        self.height = height
+        if width is None and height is None:
+            raise ValueError("You must provide either `width` or `height`!")
+
+    def _resize_frame(self, frame: np.ndarray, new_width: int, new_height: int) -> np.ndarray:
+        return cv2.resize(
+            frame,
+            (new_width, new_height),
+            interpolation=cv2.INTER_AREA,
+        )
+
+    def apply(self, video: Video) -> Video:
+        if self.width and self.height:
+            new_height = self.height
+            new_width = self.width
+        elif self.height is None and self.width:
+            video_height = video.video_shape[1]
+            video_width = video.video_shape[2]
+            new_height = round(video_height * (self.width / video_width))
+            new_width = self.width
+        elif self.width is None and self.height:
+            video_height = video.video_shape[1]
+            video_width = video.video_shape[2]
+            new_width = round(video_width * (self.height / video_height))
+            new_height = self.height
+
+        print(f"Resizing video to: {new_width}x{new_height}!")
+        with Pool() as pool:
+            frames_copy = pool.starmap(
+                self._resize_frame,
+                [(frame, new_width, new_height) for frame in video.frames],
+            )
+        video.frames = np.array(frames_copy)
+        return video
+
+
+class ResampleFPS(Transformation):
+    def __init__(self, new_fps: int | float):
+        self.new_fps = float(new_fps)
+
+    def _downsample(self, video: Video) -> Video:
+        target_frame_count = int(len(video.frames) * (self.new_fps / video.fps))
+        new_frame_indices = np.round(np.linspace(0, len(video.frames) - 1, target_frame_count)).astype(int)
+        video.frames = video.frames[new_frame_indices]
+        video.fps = self.new_fps
+        return video
+
+    def _upsample(self, video: Video) -> Video:
+        target_frame_count = int(len(video.frames) * (self.new_fps / video.fps))
+        new_frame_indices = np.linspace(0, len(video.frames) - 1, target_frame_count)
+        new_frames = []
+        for i in tqdm(range(len(new_frame_indices) - 1)):
+            # Interpolate between the two nearest frames
+            ratio = new_frame_indices[i] % 1
+            new_frame = (1 - ratio) * video.frames[int(new_frame_indices[i])] + ratio * video.frames[
+                int(np.ceil(new_frame_indices[i]))
+            ]
+            new_frames.append(new_frame.astype(np.uint8))
+        video.frames = np.array(new_frames, dtype=np.uint8)
+        video.fps = self.new_fps
+        return video
+
+    def apply(self, video: Video) -> Video:
+        if video.fps == self.new_fps:
+            return video
+        elif video.fps > self.new_fps:
+            print(f"Downsampling video from {video.fps} to {self.new_fps} FPS.")
+            video = self._downsample(video)
+        else:
+            print(f"Upsampling video from {video.fps} to {self.new_fps} FPS.")
+            video = self._upsample(video)
+        return video
+
+
+class CropMode(Enum):
+    CENTER = "center"
+
+
+class Crop(Transformation):
+
+    def __init__(self, width: int, height: int, mode: CropMode = CropMode.CENTER):
+        self.width = width
+        self.height = height
+        self.mode = mode
+
+    def apply(self, video: Video) -> Video:
+        if self.mode == CropMode.CENTER:
+            current_shape = video.frame_shape[:2]
+            center_height = current_shape[0] // 2
+            center_width = current_shape[1] // 2
+            width_offset = self.width // 2
+            height_offset = self.height // 2
+            video.frames = video.frames[
+                :,
+                center_height - height_offset : center_height + height_offset,
+                center_width - width_offset : center_width + width_offset,
+                :,
+            ]
+        else:
+            raise ValueError(f"Unknown mode: {self.mode}")
+        return video

{videopython-0.1.2 → videopython-0.1.4}/src/videopython/base/transitions.py

@@ -4,6 +4,7 @@ from typing import final
 
 import numpy as np
 
+from videopython.base.effects import Blur
 from videopython.base.video import Video
 
 
@@ -15,19 +16,19 @@ class Transition(ABC):
     """
 
     @final
-    def apply(self, videos: tuple[Video, Video], **kwargs) -> Video:
+    def apply(self, videos: tuple[Video, Video]) -> Video:
         assert videos[0].metadata.can_be_merged_with(videos[1].metadata)
-        return self._apply(videos, **kwargs)
+        return self._apply(videos)
 
     @abstractmethod
-    def _apply(self, videos: tuple[Video, Video], **kwargs) -> Video:
+    def _apply(self, videos: tuple[Video, Video]) -> Video:
         pass
 
 
 class InstantTransition(Transition):
     """Instant cut without any transition."""
 
-    def _apply(self, videos: list[Video] | tuple[Video]) -> Video:
+    def _apply(self, videos: tuple[Video, Video]) -> Video:
         return videos[0] + videos[1]
 
 
@@ -57,7 +58,7 @@ class FadeTransition(Transition):
         effect_time_fps = math.floor(self.effect_time_seconds * video_fps)
         transition = self.fade(videos[0].frames[-effect_time_fps:], videos[1].frames[:effect_time_fps])
 
-        return Video.from_frames(
+        faded_videos = Video.from_frames(
             np.r_[
                 "0,2",
                 videos[0].frames[:-effect_time_fps],
@@ -66,3 +67,40 @@ class FadeTransition(Transition):
             ],
             fps=video_fps,
         )
+        faded_videos.audio = videos[0].audio.append(videos[1].audio, crossfade=(effect_time_fps / video_fps) * 1000)
+        return faded_videos
+
+
+class BlurTransition(Transition):
+    def __init__(
+        self, effect_time_seconds: float = 1.5, blur_iterations: int = 400, blur_kernel_size: tuple[int, int] = (11, 11)
+    ):
+        self.effect_time_seconds = effect_time_seconds
+        self.blur_iterations = blur_iterations
+        self.blur_kernel_size = blur_kernel_size
+
+    def _apply(self, videos: tuple[Video, Video]) -> Video:
+        video_fps = videos[0].fps
+        for video in videos:
+            if video.total_seconds < self.effect_time_seconds:
+                raise RuntimeError("Not enough space to make transition!")
+
+        effect_time_fps = math.floor(self.effect_time_seconds * video_fps)
+
+        ascending_blur = Blur("ascending", self.blur_iterations, self.blur_kernel_size)
+        descending_blur = Blur("descending", self.blur_iterations, self.blur_kernel_size)
+        transition = ascending_blur.apply(videos[0][-effect_time_fps:]) + descending_blur.apply(
+            videos[1][:effect_time_fps]
+        )
+
+        blurred_videos = Video.from_frames(
+            np.r_[
+                "0,2",
+                videos[0].frames[:-effect_time_fps],
+                transition.frames,
+                videos[1].frames[effect_time_fps:],
+            ],
+            fps=video_fps,
+        )
+        blurred_videos.audio = videos[0].audio.append(videos[1].audio)
+        return blurred_videos