videopython 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

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/base/transforms.py

@@ -1,8 +1,11 @@
 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
 
@@ -14,9 +17,6 @@ class Transformation(ABC):
     def apply(self, video: Video) -> Video:
         pass
 
-    def __call__(self, video: Video) -> Video:
-        return self.apply(video)
-
 
 class TransformationPipeline:
     def __init__(self, transformations: list[Transformation] | None):
@@ -58,7 +58,7 @@ class CutFrames(Transformation):
         self.end_frame = end_frame
 
     def apply(self, video: Video) -> Video:
-        video.frames = video.frames[self.start_frame : self.end_frame]
+        video = video[self.start_frame : self.end_frame]
         return video
 
 
@@ -68,14 +68,16 @@ class CutSeconds(Transformation):
         self.end_second = end_second
 
     def apply(self, video: Video) -> Video:
-        video.frames = video.frames[round(self.start_second * video.fps) : round(self.end_second * video.fps)]
+        video = video[round(self.start_second * video.fps) : round(self.end_second * video.fps)]
         return video
 
 
 class Resize(Transformation):
-    def __init__(self, new_width: int, new_height: int):
-        self.new_width = new_width
-        self.new_height = new_height
+    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(
@@ -85,10 +87,92 @@ class Resize(Transformation):
         )
 
     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, self.new_width, self.new_height) for frame in video.frames],
+                [(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/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

videopython/base/video.py

@@ -7,11 +7,9 @@ from pathlib import Path
 
 import cv2
 import numpy as np
-import torch
-from diffusers import DiffusionPipeline, DPMSolverMultistepScheduler
 from pydub import AudioSegment
 
-from videopython.utils.common import generate_random_name
+from videopython.utils.common import check_path, generate_random_name
 
 
 @dataclass
@@ -25,7 +23,7 @@ class VideoMetadata:
     total_seconds: float
 
     def __str__(self):
-        return f"{self.height}x{self.width} @ {self.fps}fps, {self.total_seconds} seconds"
+        return f"{self.width}x{self.height} @ {self.fps}fps, {self.total_seconds} seconds"
 
     def __repr__(self) -> str:
         return self.__str__()
@@ -117,16 +115,22 @@ class Video:
         audio = cls._load_audio_from_path(path)
         if not audio:
             print(f"No audio found for `{path}`, adding silent track!")
-            audio = AudioSegment.silent(duration=new_vid.total_seconds * 1000)
+            audio = AudioSegment.silent(duration=round(new_vid.total_seconds * 1000))
         new_vid.audio = audio
         return new_vid
 
     @classmethod
     def from_frames(cls, frames: np.ndarray, fps: float) -> Video:
         new_vid = cls()
+        if frames.ndim != 4:
+            raise ValueError(f"Unsupported number of dimensions: {frames.shape}!")
+        elif frames.shape[-1] == 4:
+            frames = frames[:, :, :, :3]
+        elif frames.shape[-1] != 3:
+            raise ValueError(f"Unsupported number of dimensions: {frames.shape}!")
         new_vid.frames = frames
         new_vid.fps = fps
-        new_vid.audio = AudioSegment.silent(duration=new_vid.total_seconds * 1000)
+        new_vid.audio = AudioSegment.silent(duration=round(new_vid.total_seconds * 1000))
         return new_vid
 
     @classmethod
@@ -136,37 +140,9 @@ class Video:
             image = np.expand_dims(image, axis=0)
         new_vid.frames = np.repeat(image, round(length_seconds * fps), axis=0)
         new_vid.fps = fps
-        new_vid.audio = AudioSegment.silent(duration=new_vid.total_seconds * 1000)
+        new_vid.audio = AudioSegment.silent(duration=round(new_vid.total_seconds * 1000))
         return new_vid
 
-    @classmethod
-    def from_prompt(
-        cls,
-        prompt: str,
-        num_steps: int = 25,
-        height: int = 320,
-        width: int = 576,
-        num_frames: int = 24,
-        gpu_optimized: bool = False,
-    ) -> Video:
-        pipe = DiffusionPipeline.from_pretrained("cerspense/zeroscope_v2_576w", torch_dtype=torch_dtype)
-        if gpu_optimized:
-            pipe.enable_model_cpu_offload()
-            torch_dtype = torch.float16
-        else:
-            torch_dtype = torch.float32
-        pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
-        video_frames = np.asarray(
-            pipe(
-                prompt,
-                num_inference_steps=num_steps,
-                height=height,
-                width=width,
-                num_frames=num_frames,
-            ).frames
-        )
-        return Video.from_frames(video_frames, fps=24.0)
-
     def copy(self) -> Video:
         copied = Video().from_frames(self.frames.copy(), self.fps)
         copied.audio = self.audio
@@ -198,19 +174,10 @@ class Video:
         """
         if not self.is_loaded():
             raise RuntimeError(f"Video is not loaded, cannot save!")
-        # Check filename correctness or generate a new one if not given
-        if not filename:
-            filename = Path(generate_random_name()).resolve()
-            directory = filename.parent
-        elif not Path(filename).suffix == ".mp4":
-            raise ValueError("Only .mp4 save option is supported.")
-        else:
-            filename = Path(filename)
-            directory = filename.parent
-            if not directory.exists():
-                raise ValueError(f"Selected directory `{directory}` does not exist!")
 
-        filename, directory = str(filename), str(directory)
+        if filename is None:
+            filename = generate_random_name(suffix=".mp4")
+        filename = check_path(filename, dir_exists=True, suffix=".mp4")
 
         ffmpeg_video_command = (
             f"ffmpeg -loglevel error -y -framerate {self.fps} -f rawvideo -pix_fmt rgb24"
@@ -250,10 +217,14 @@ class Video:
 
     def add_audio_from_file(self, path: str, overlay: bool = True, overlay_gain: int = 0, loop: bool = False) -> None:
         new_audio = self._load_audio_from_path(path)
-        if (duration_diff := self.total_seconds - new_audio.duration_seconds) > 0 and not loop:
+        if new_audio is None:
+            print(f"Audio file `{path}` not found, skipping!")
+            return
+
+        if (duration_diff := round(self.total_seconds - new_audio.duration_seconds)) > 0 and not loop:
             new_audio = new_audio + AudioSegment.silent(duration_diff * 1000)
         elif new_audio.duration_seconds > self.total_seconds:
-            new_audio = new_audio[: self.total_seconds * 1000]
+            new_audio = new_audio[: round(self.total_seconds * 1000)]
 
         if overlay:
             self.audio = self.audio.overlay(new_audio, loop=loop, gain_during_overlay=overlay_gain)
@@ -276,17 +247,25 @@ class Video:
     def __str__(self) -> str:
         return str(self.metadata)
 
-    def __getitem__(self, val: int | slice) -> Video | np.ndarray:
-        if isinstance(val, slice):
-            # Sub-slice video if given a slice
-            sliced = self.from_frames(self.frames[val], fps=self.fps)
-            audio_start = (val.start / self.fps) * 1000
-            audio_end = (val.stop / self.fps) * 1000
-            sliced.audio = self.audio[audio_start:audio_end]
-            return sliced
-        elif isinstance(val, int):
-            # Return single frame for integer indexing
-            return self.frames[val]
+    def __getitem__(self, val: slice) -> Video:
+        if not isinstance(val, slice):
+            raise ValueError("Only slices are supported for video indexing!")
+
+        # Sub-slice video if given a slice
+        sliced = self.from_frames(self.frames[val], fps=self.fps)
+        # Handle slicing without value for audio
+        start = val.start if val.start else 0
+        stop = val.stop if val.stop else len(self.frames)
+        # Handle negative values for audio slices
+        if start < 0:
+            start = len(self.frames) + start
+        if stop < 0:
+            stop = len(self.frames) + stop
+        # Append audio to the slice
+        audio_start = round(start / self.fps) * 1000
+        audio_end = round(stop / self.fps) * 1000
+        sliced.audio = self.audio[audio_start:audio_end]
+        return sliced
 
     @staticmethod
     def _load_audio_from_path(path: str) -> AudioSegment | None:

videopython/generation/__init__.py

@@ -0,0 +1,10 @@
+from .audio import TextToSpeech
+from .image import TextToImage
+from .video import ImageToVideo, TextToVideo
+
+__all__ = [
+    "ImageToVideo",
+    "TextToSpeech",
+    "TextToImage",
+    "TextToVideo",
+]

videopython/generation/audio.py

@@ -0,0 +1,22 @@
+import numpy as np
+import torch
+from pydub import AudioSegment
+from transformers import AutoTokenizer, VitsModel
+
+TEXT_TO_SPEECH_MODEL = "facebook/mms-tts-eng"
+
+
+class TextToSpeech:
+    def __init__(self):
+        self.pipeline = VitsModel.from_pretrained(TEXT_TO_SPEECH_MODEL)
+        self.tokenizer = AutoTokenizer.from_pretrained(TEXT_TO_SPEECH_MODEL)
+
+    def generate_audio(self, text: str) -> AudioSegment:
+        tokenized = self.tokenizer(text, return_tensors="pt")
+
+        with torch.no_grad():
+            output = self.pipeline(**tokenized).waveform
+
+        output = (output.T.float().numpy() * (2**31 - 1)).astype(np.int32)
+        audio = AudioSegment(data=output, frame_rate=self.pipeline.config.sampling_rate, sample_width=4, channels=1)
+        return audio

videopython/generation/image.py

@@ -0,0 +1,22 @@
+import io
+import os
+
+import torch
+from diffusers import DiffusionPipeline
+from PIL import Image
+
+TEXT_TO_IMAGE_MODEL = "stabilityai/stable-diffusion-xl-base-1.0"
+
+
+class TextToImage:
+    def __init__(self):
+        if not torch.cuda.is_available():
+            raise ValueError("CUDA is not available, but TextToVideo model requires CUDA.")
+        self.pipeline = DiffusionPipeline.from_pretrained(
+            TEXT_TO_IMAGE_MODEL, torch_dtype=torch.float16, variant="fp16", use_safetensors=True
+        )
+        self.pipeline.to("cuda")
+
+    def generate_image(self, prompt: str) -> Image.Image:
+        image = self.pipeline(prompt=prompt).images[0]
+        return image

videopython/generation/video.py

@@ -0,0 +1,45 @@
+import numpy as np
+import torch
+from diffusers import DiffusionPipeline, DPMSolverMultistepScheduler
+from PIL.Image import Image
+
+from videopython.base.video import Video
+
+TEXT_TO_VIDEO_MODEL = "cerspense/zeroscope_v2_576w"
+IMAGE_TO_VIDEO_MODEL = "stabilityai/stable-video-diffusion-img2vid-xt"
+
+
+class TextToVideo:
+    def __init__(self):
+        if not torch.cuda.is_available():
+            raise ValueError("CUDA is not available, but TextToVideo model requires CUDA.")
+        self.pipeline = DiffusionPipeline.from_pretrained(TEXT_TO_VIDEO_MODEL, torch_dtype=torch.float16)
+        self.pipeline.scheduler = DPMSolverMultistepScheduler.from_config(self.pipeline.scheduler.config)
+        self.pipeline.to("cuda")
+
+    def generate_video(
+        self, prompt: str, num_steps: int = 25, height: int = 320, width: int = 576, num_frames: int = 24
+    ) -> Video:
+        video_frames = self.pipeline(
+            prompt,
+            num_inference_steps=num_steps,
+            height=height,
+            width=width,
+            num_frames=num_frames,
+        ).frames[0]
+        video_frames = np.asarray(255 * video_frames, dtype=np.uint8)
+        return Video.from_frames(video_frames, fps=24.0)
+
+
+class ImageToVideo:
+    def __init__(self):
+        if not torch.cuda.is_available():
+            raise ValueError("CUDA is not available, but ImageToVideo model requires CUDA.")
+        self.pipeline = DiffusionPipeline.from_pretrained(
+            IMAGE_TO_VIDEO_MODEL, torch_dtype=torch.float16, variant="fp16"
+        ).to("cuda")
+
+    def generate_video(self, image: Image, fps: int = 24) -> Video:
+        video_frames = self.pipeline(image=image, fps=fps, output_type="np").frames[0]
+        video_frames = np.asarray(255 * video_frames, dtype=np.uint8)
+        return Video.from_frames(video_frames, fps=float(fps))

videopython/utils/common.py

@@ -1,5 +1,7 @@
 import time
 import uuid
+from pathlib import Path
+from typing import Callable
 
 
 def generate_random_name(suffix=".mp4"):
@@ -7,7 +9,7 @@ def generate_random_name(suffix=".mp4"):
     return f"{uuid.uuid4()}{suffix}"
 
 
-def timeit(func: callable):
+def timeit(func: Callable):
     """Decorator to measure execution time of a function."""
 
     def timed(*args, **kwargs):
@@ -18,3 +20,12 @@ def timeit(func: callable):
         return result
 
     return timed
+
+
+def check_path(path: str, dir_exists: bool = True, suffix: str | None = None) -> str:
+    fullpath = Path(path).resolve()
+    if dir_exists and not fullpath.parent.exists():
+        raise ValueError(f"Directory `{fullpath.parent}` does not exist!")
+    if suffix and suffix != fullpath.suffix:
+        raise ValueError(f"Required suffix `{suffix}` does not match the file suffix `{fullpath.suffix}`")
+    return str(fullpath)

videopython/utils/image.py

@@ -0,0 +1,275 @@
+from typing import Literal
+
+import cv2
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+
+from videopython.base.video import Video
+from videopython.exceptions import OutOfBoundsError
+
+
+class ImageText:
+    def __init__(
+        self,
+        image_size: tuple[int, int] = (1080, 1920),  # (width, height)
+        mode: str = "RGBA",
+        background: tuple[int, int, int, int] = (0, 0, 0, 0),  # Transparent background
+    ):
+        self.image_size = image_size
+        self.image = Image.new(mode, image_size, color=background)
+        self._draw = ImageDraw.Draw(self.image)
+
+    @property
+    def img_array(self) -> np.ndarray:
+        return np.array(self.image)
+
+    def save(self, filename: str) -> None:
+        self.image.save(filename)
+
+    def _fit_font_width(self, text: str, font: str, max_width: int) -> int:
+        """Find the maximum font size where the text width is less than or equal to max_width."""
+        font_size = 1
+        text_width = self.get_text_size(font, font_size, text)[0]
+        while text_width < max_width:
+            font_size += 1
+            text_width = self.get_text_size(font, font_size, text)[0]
+        max_font_size = font_size - 1
+        if max_font_size < 1:
+            raise ValueError(f"Max height {max_width} is too small for any font size!")
+        return max_font_size
+
+    def _fit_font_height(self, text: str, font: str, max_height: int) -> int:
+        """Find the maximum font size where the text height is less than or equal to max_height."""
+        font_size = 1
+        text_height = self.get_text_size(font, font_size, text)[1]
+        while text_height < max_height:
+            font_size += 1
+            text_height = self.get_text_size(font, font_size, text)[1]
+        max_font_size = font_size - 1
+        if max_font_size < 1:
+            raise ValueError(f"Max height {max_height} is too small for any font size!")
+        return max_font_size
+
+    def _get_font_size(
+        self,
+        text: str,
+        font: str,
+        max_width: int | None = None,
+        max_height: int | None = None,
+    ) -> int:
+        """Get maximum font size for `text` to fill in the `max_width` and `max_height`."""
+        if max_width is None and max_height is None:
+            raise ValueError("You need to pass max_width or max_height")
+        if max_width is not None:
+            width_font_size = self._fit_font_width(text, font, max_width)
+        if max_height is not None:
+            height_font_size = self._fit_font_height(text, font, max_height)
+        return min([size for size in [width_font_size, height_font_size] if size is not None])
+
+    def write_text(
+        self,
+        text: str,
+        font_filename: str,
+        xy: tuple[int, int],
+        font_size: int | None = 11,
+        color: tuple[int, int, int] = (0, 0, 0),
+        max_width: int | None = None,
+        max_height: int | None = None,
+    ) -> tuple[int, int]:
+        x, y = xy
+        if font_size is None and (max_width is None or max_height is None):
+            raise ValueError(f"Must set either `font_size`, or both `max_width` and `max_height`!")
+        elif font_size is None:
+            font_size = self._get_font_size(text, font_filename, max_width, max_height)
+        text_size = self.get_text_size(font_filename, font_size, text)
+        if (text_size[0] + x > self.image_size[0]) or (text_size[1] + y > self.image_size[1]):
+            raise OutOfBoundsError(f"Font size `{font_size}` is too big, text won't fit!")
+        font = ImageFont.truetype(font_filename, font_size)
+        self._draw.text((x, y), text, font=font, fill=color)
+        return text_size
+
+    def get_text_size(self, font_filename: str, font_size: int, text: str) -> tuple[int, int]:
+        """Return bounding box size of the rendered `text` with `font_filename` and `font_size`."""
+        font = ImageFont.truetype(font_filename, font_size)
+        return font.getbbox(text)[2:]
+
+    def _split_lines_by_width(
+        self,
+        text: str,
+        font_filename: str,
+        font_size: int,
+        box_width: int,
+    ) -> list[str]:
+        """Split the `text` into lines of maximum `box_width`."""
+        words = text.split()
+        split_lines: list[list[str]] = []
+        current_line: list[str] = []
+        for word in words:
+            new_line = " ".join(current_line + [word])
+            size = self.get_text_size(font_filename, font_size, new_line)
+            if size[0] <= box_width:
+                current_line.append(word)
+            else:
+                split_lines.append(current_line)
+                current_line = [word]
+        if current_line:
+            split_lines.append(current_line)
+        lines = [" ".join(line) for line in split_lines]
+        return lines
+
+    def write_text_box(
+        self,
+        text: str,
+        font_filename: str,
+        xy: tuple[int, int],
+        box_width: int,
+        font_size: int = 11,
+        text_color: tuple[int, int, int] = (0, 0, 0),
+        background_color: None | tuple[int, int, int, int] = None,
+        background_padding: int = 0,
+        place: Literal["left", "right", "center"] = "left",
+    ) -> tuple[int, int]:
+        """Write text in box described by upper-left corner and maxium width of the box.
+
+        Args:
+            text: Text to be written inside the box.
+            font_filename: Path to the font file.
+            xy: X and Y coordinates describing upper-left of the box containing the text.
+            box_width: Pixel width of the box containing the text.
+            font_size: Font size.
+            text_color: RGB color of the text.
+            background_color: If set, adds background color to the text box. Expects RGBA values.
+            background_padding: Number of padding pixels to add when adding text background color.
+            place: Strategy for justifying the text inside the container box. Defaults to "left".
+
+        Returns:
+            Lower-left corner of the written text box.
+        """
+        x, y = xy
+        lines = self._split_lines_by_width(text, font_filename, font_size, box_width)
+        # Run checks to see if the text will fit
+        if x + box_width > self.image_size[0]:
+            raise OutOfBoundsError(f"Box width {box_width} is too big for the image width {self.image_size[0]}!")
+        lines_height = sum([self.get_text_size(font_filename, font_size, line)[1] for line in lines])
+        if y + lines_height > self.image_size[1]:
+            available_space = self.image_size[1] - y
+            raise OutOfBoundsError(f"Text height {lines_height} is too big for the available space {available_space}!")
+        # Write lines
+        current_text_height = y
+        for line in lines:
+            line_size = self.get_text_size(font_filename, font_size, line)
+            # Write line text into the image
+            if place == "left":
+                self.write_text(
+                    text=line,
+                    font_filename=font_filename,
+                    xy=(x, current_text_height),
+                    font_size=font_size,
+                    color=text_color,
+                )
+            elif place == "right":
+                x_left = x + box_width - line_size[0]
+                self.write_text(
+                    text=line,
+                    font_filename=font_filename,
+                    xy=(x_left, current_text_height),
+                    font_size=font_size,
+                    color=text_color,
+                )
+            elif place == "center":
+                x_left = int(x + ((box_width - line_size[0]) / 2))
+                self.write_text(
+                    text=line,
+                    font_filename=font_filename,
+                    xy=(x_left, current_text_height),
+                    font_size=font_size,
+                    color=text_color,
+                )
+            else:
+                raise ValueError(f"Place {place} is not supported. Use one of: `left`, `right` or `center`!")
+            # Increment text height
+            current_text_height += line_size[1]
+        # Add background color for the text if set
+        if background_color is not None:
+            if len(background_color) != 4:
+                raise ValueError(f"Text background color {background_color} must be RGBA!")
+            img = self.img_array
+            # Find bounding rectangle for written text
+            box_slice = img[y:current_text_height, x : x + box_width]
+            text_mask = np.any(box_slice != 0, axis=2).astype(np.uint8)
+            xmin, xmax, ymin, ymax = self._find_smallest_bounding_rect(text_mask)
+            # Get global bounding box position
+            xmin += x - background_padding
+            xmax += x + background_padding
+            ymin += y - background_padding
+            ymax += y + background_padding
+            # Make sure we are inside image, cut to image if not
+            xmin = max(0, xmin)
+            ymin = max(0, ymin)
+            xmax = min(xmax, self.image_size[0])
+            ymax = min(ymax, self.image_size[1])
+            # Slice the bounding box and find text mask
+            bbox_slice = img[ymin:ymax, xmin:xmax]
+            bbox_text_mask = np.any(bbox_slice != 0, axis=2).astype(np.uint8)
+            # Add background color outside of text
+            bbox_slice[~bbox_text_mask.astype(bool)] = background_color
+            # Blur nicely with semi-transparent pixels from the font
+            text_slice = bbox_slice[bbox_text_mask.astype(bool)]
+            text_background = text_slice[:, :3] * (np.expand_dims(text_slice[:, -1], axis=1) / 255)
+            color_background = (1 - (np.expand_dims(text_slice[:, -1], axis=1) / 255)) * background_color
+            faded_background = text_background[:, :3] + color_background[:, :3]
+            text_slice[:, :3] = faded_background
+            text_slice[:, -1] = 255
+            bbox_slice[bbox_text_mask.astype(bool)] = text_slice
+            # Set image with the background color
+            self.image = Image.fromarray(img)
+        return (x, current_text_height)
+
+    def _find_smallest_bounding_rect(self, mask: np.ndarray) -> tuple[int, int, int, int]:
+        """Find the smallest bounding rectangle for the mask."""
+        rows = np.any(mask, axis=1)
+        cols = np.any(mask, axis=0)
+        ymin, ymax = np.where(rows)[0][[0, -1]]
+        xmin, xmax = np.where(cols)[0][[0, -1]]
+        return xmin, xmax, ymin, ymax
+
+
+class SlideOverImage:
+    def __init__(
+        self,
+        direction: Literal["left", "right"],
+        video_shape: tuple[int, int] = (1080, 1920),
+        fps: float = 24.0,
+        length_seconds: float = 1.0,
+    ) -> None:
+        self.direction = direction
+        self.video_width, self.video_height = video_shape
+        self.fps = fps
+        self.length_seconds = length_seconds
+
+    def slide(self, image: np.ndarray) -> Video:
+        image = self._resize(image)
+        max_offset = image.shape[1] - self.video_width
+        frame_count = round(self.fps * self.length_seconds)
+
+        deltas = np.linspace(0, max_offset, frame_count)
+        frames = []
+
+        for delta in deltas:
+            if self.direction == "right":
+                frame = image[:, round(delta) : round(delta) + self.video_width]
+            elif self.direction == "left":
+                frame = image[:, image.shape[1] - round(delta) - self.video_width : image.shape[1] - round(delta)]
+            frames.append(frame)
+
+        return Video.from_frames(frames=np.stack(frames, axis=0), fps=self.fps)
+
+    def _resize(self, image: np.ndarray) -> np.ndarray:
+        resize_factor = image.shape[0] / self.video_height
+        resize_dims = (round(image.shape[1] / resize_factor), round(image.shape[0] / resize_factor))  # width, height
+        image = cv2.resize(image, resize_dims)
+        if self.video_height > image.shape[0] or self.video_width > image.shape[1]:
+            raise ValueError(
+                f"Image `{image.shape}` is too small for the video frame `({self.video_width}, {self.video_height})`!"
+            )
+        return image

{videopython-0.1.2.dist-info → videopython-0.1.4.dist-info}/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,18 @@
+videopython/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+videopython/base/compose.py,sha256=pti12VY3Yg7TZZiENPF6veM8POWssfsK8ePDdGlhAhA,1968
+videopython/base/effects.py,sha256=ZFUWrgVWTn4uWpxPfTQSQQKEZN5ns4btMofOZNHCeQc,7540
+videopython/base/transforms.py,sha256=yDtM1uZOacB0OLPQnSGHl5upoNNeN0dPWXe0hJPeV-I,6004
+videopython/base/transitions.py,sha256=zYsxIgiVfN9P-CoGWUWRYFBr_0inX1sAJ02gyIEQ678,3694
+videopython/base/video.py,sha256=kG-juKN-da5NzV89YxZl5JkyMTJFkgPceh4yuAUnsQs,11099
+videopython/generation/__init__.py,sha256=Qse024UgiS9OxXzbbInyZ-9cpfI4enR2Dcds4lLDpNA,201
+videopython/generation/audio.py,sha256=BTc-3vJ5e6D0lt2OPo2hfOcUqhNXIcvRLNoo2oQ470M,777
+videopython/generation/image.py,sha256=i8zJm0WXn_Pykby9Urw1kzDcla6ArYhRgG-ueRdoAJ0,675
+videopython/generation/video.py,sha256=WMFKKUSfIkQmxL6xhUb-MeAiHU6uOF_oFpmf69H8V8g,1827
+videopython/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+videopython/utils/common.py,sha256=F-30YoKUwWDI7HiJUWw0gRFUguhShSVaxT0aFfvpifg,936
+videopython/utils/image.py,sha256=CaZ-XAbnIemzvYDNpZACLmIVKt9Zw20STvOptCrUXiw,12079
+videopython-0.1.4.dist-info/LICENSE,sha256=nJL9jVOt2MSW7swNDq4Y6oD_n9bLI0B0afr8ougtZ6s,10832
+videopython-0.1.4.dist-info/METADATA,sha256=bKgx5rLr4t95KWNDw65QjuoUdLr2zbaajd76whhCQF0,15658
+videopython-0.1.4.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+videopython-0.1.4.dist-info/top_level.txt,sha256=OikTGG8Swfw_syz--1atAn5KQ4GH9Pye17eATGred-Q,12
+videopython-0.1.4.dist-info/RECORD,,

{videopython-0.1.2.dist-info → videopython-0.1.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

videopython/generation/openai/text_to_speech.py

@@ -1,31 +0,0 @@
-import os
-from pathlib import Path
-
-from openai import OpenAI
-from pydub import AudioSegment
-
-from videopython.utils.common import generate_random_name
-
-
-def text_to_speech_openai(
-    text: str, voice: str = "alloy", save: bool = True, output_dir: str | None = None
-) -> str | AudioSegment:
-    client = OpenAI()
-
-    filename = generate_random_name(suffix=".mp3")
-    if output_dir:
-        output_dir = Path(output_dir)
-        output_dir.mkdir(parents=True, exist_ok=True)
-    else:
-        output_dir = Path(os.getcwd())
-    save_path = output_dir / filename
-
-    response = client.audio.speech.create(model="tts-1", voice=voice, input=text)
-    response.stream_to_file(save_path)
-
-    if save:
-        return str(save_path.resolve())
-    else:
-        audio = AudioSegment.from_mp3(str(save_path))
-        save_path.unlink()
-        return audio

videopython/generation/stability/text_to_image.py

@@ -1,77 +0,0 @@
-import io
-import os
-from pathlib import Path
-
-import numpy as np
-import stability_sdk.interfaces.gooseai.generation.generation_pb2 as generation
-from PIL import Image
-from stability_sdk import client
-
-from videopython.utils.common import generate_random_name
-
-API_KEY = os.getenv("STABILITY_KEY")
-if not API_KEY:
-    raise KeyError(
-        "Stability API key was not found in the environment! Please set in as `STABILITY_KEY` in your environment."
-    )
-
-
-def text_to_image(
-    prompt: str,
-    save: bool = True,
-    output_dir: str | None = None,
-    width: int = 1024,
-    height: int = 1024,
-    num_samples: int = 1,
-    steps: int = 30,
-    cfg_scale: float = 8.0,
-    engine: str = "stable-diffusion-xl-1024-v1-0",
-    verbose: bool = True,
-    seed: int = 1,
-) -> np.ndarray | str:
-    """Generates image from prompt using the stability.ai API."""
-    # Generate image
-    stability_api = client.StabilityInference(
-        key=API_KEY,
-        verbose=verbose,
-        engine=engine,  # Set the engine to use for generation.
-        # Check out the following link for a list of available engines: https://platform.stability.ai/docs/features/api-parameters#engine
-    )
-    answers = stability_api.generate(
-        prompt=prompt,
-        seed=seed,
-        steps=steps,  # Amount of inference steps performed on image generation.
-        cfg_scale=cfg_scale,  # Influences how strongly your generation is guided to match your prompt.
-        # Setting this value higher increases the strength in which it tries to match your prompt.
-        # Defaults to 7.0 if not specified.
-        width=width,
-        height=height,
-        samples=num_samples,
-        sampler=generation.SAMPLER_K_DPMPP_2M  # Choose which sampler we want to denoise our generation with.
-        # Defaults to k_dpmpp_2m if not specified. Clip Guidance only supports ancestral samplers.
-        # (Available Samplers: ddim, plms, k_euler, k_euler_ancestral, k_heun, k_dpm_2, k_dpm_2_ancestral, k_dpmpp_2s_ancestral, k_lms, k_dpmpp_2m, k_dpmpp_sde)
-    )
-    # Parse API response
-    for resp in answers:
-        for artifact in resp.artifacts:
-            if artifact.finish_reason == generation.FILTER:
-                raise RuntimeError(
-                    "Your request activated the API's safety filters and could not be processed."
-                    "Please modify the prompt and try again."
-                )
-            if artifact.type == generation.ARTIFACT_IMAGE:
-                img = Image.open(io.BytesIO(artifact.binary))
-            else:
-                raise ValueError(f"Unknown artifact type: {artifact.type}")
-
-    if save:
-        if output_dir:
-            output_dir = Path(output_dir)
-            output_dir.mkdir(parents=True, exist_ok=True)
-        else:
-            output_dir = Path(os.getcwd())
-        filename = output_dir / generate_random_name(suffix=".png")
-        img.save(filename)
-        return str(filename.resolve())
-    else:
-        return np.array(img)

videopython-0.1.2.dist-info/RECORD

@@ -1,15 +0,0 @@
-videopython/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-videopython/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-videopython/base/compose.py,sha256=pti12VY3Yg7TZZiENPF6veM8POWssfsK8ePDdGlhAhA,1968
-videopython/base/transforms.py,sha256=aXIqbp9sZkZI5PYRn0uDSxLoQxCdku1BAmzfQpnGW_w,2701
-videopython/base/transitions.py,sha256=VQXJ-sGL7lcr3Q6uhb66hLlqW9213UBUAAH6DqJa9xs,2159
-videopython/base/video.py,sha256=Pn2vRRLicNRhju1qkK-QUkvtgcTNEUzaQPA8cZqqpwQ,11767
-videopython/generation/openai/text_to_speech.py,sha256=d5Sli8kAiIAW_ugyLAxS4yQ7jcW4_NAI6hqy6QdpAU8,852
-videopython/generation/stability/text_to_image.py,sha256=K6_xWVAUlFLUd-Hj6T-l3QgfxZfV_kx8KYIDpqiiNSo,2983
-videopython/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-videopython/utils/common.py,sha256=-7YPlggyteVg_QbylDgBRm7yuWwuWvnlOIEVyuCzZhw,455
-videopython-0.1.2.dist-info/LICENSE,sha256=nJL9jVOt2MSW7swNDq4Y6oD_n9bLI0B0afr8ougtZ6s,10832
-videopython-0.1.2.dist-info/METADATA,sha256=YktibiiRKPOCZpRp0Yna8tYyp5oWuPRYiU7E_oUtz44,14709
-videopython-0.1.2.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-videopython-0.1.2.dist-info/top_level.txt,sha256=OikTGG8Swfw_syz--1atAn5KQ4GH9Pye17eATGred-Q,12
-videopython-0.1.2.dist-info/RECORD,,