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

videopython/base/effects.py

@@ -1,7 +1,9 @@
 from abc import ABC, abstractmethod
-from typing import final
+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
@@ -14,12 +16,35 @@ class Effect(ABC):
     """
 
     @final
-    def apply(self, video: Video) -> Video:
+    def apply(self, video: Video, start: float | None = None, stop: float | None = None) -> Video:
         original_shape = video.video_shape
-        video_with_effect = self._apply(video)
-        if not video_with_effect.video_shape == original_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_with_effect
+
+        return video
 
     @abstractmethod
     def _apply(self, video: Video) -> Video:
@@ -27,7 +52,7 @@ class Effect(ABC):
 
 
 class FullImageOverlay(Effect):
-    def __init__(self, overlay_image: np.ndarray, alpha: float | None = None):
+    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]):
@@ -37,21 +62,122 @@ class FullImageOverlay(Effect):
 
         if overlay_image.shape[-1] == 3:
             overlay_image = np.dstack([overlay_image, np.full(overlay_image.shape[:2], 255, dtype=np.uint8)])
-        overlay_image[:, :, 3] = overlay_image[:, :, 3] * alpha
-
-        self._overlay_alpha = (overlay_image[:, :, 3] / 255.0)[:, :, np.newaxis]
-        self._base_transparency = 1 - self._overlay_alpha
 
-        self.overlay = overlay_image[:, :, :3] * self._overlay_alpha
+        self.alpha = alpha
+        self.overlay = overlay_image.astype(np.uint8)
+        self.fade_time = fade_time
 
-    def _overlay(self, img: np.ndarray) -> np.ndarray:
-        return self.overlay + (img * self._base_transparency)
+    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.shape:
+        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...")
-        video.frames = np.array([self._overlay(frame) for frame in tqdm(video.frames)], dtype=np.uint8)
+        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,5 +1,7 @@
 from abc import ABC, abstractmethod
+from enum import Enum
 from multiprocessing import Pool
+from typing import Literal
 
 import cv2
 import numpy as np
@@ -71,9 +73,11 @@ class CutSeconds(Transformation):
 
 
 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(
@@ -83,10 +87,25 @@ 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
@@ -128,3 +147,32 @@ class ResampleFPS(Transformation):
             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
 
 
@@ -68,3 +69,38 @@ class FadeTransition(Transition):
         )
         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

@@ -23,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__()
@@ -122,6 +122,12 @@ class Video:
     @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=round(new_vid.total_seconds * 1000))

videopython/generation/audio.py

@@ -1,30 +1,22 @@
-import os
-from pathlib import Path
-from typing import Literal
-
-from openai import OpenAI
+import numpy as np
+import torch
 from pydub import AudioSegment
+from transformers import AutoTokenizer, VitsModel
 
-from videopython.utils.common import generate_random_name
+TEXT_TO_SPEECH_MODEL = "facebook/mms-tts-eng"
 
 
 class TextToSpeech:
-    def __init__(self, openai_key: str | None = None, save_audio: bool = True):
-        self.client = OpenAI(api_key=openai_key)
-        self._save = save_audio
+    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
 
-    def generate_audio(
-        self,
-        text: str,
-        voice: Literal["alloy", "echo", "fable", "onyx", "nova", "shimmer"] = "alloy",
-    ) -> AudioSegment:
-        filename = generate_random_name(suffix=".mp3")
-        output_path = str((Path(os.getcwd()) / filename).resolve())
-        response = self.client.audio.speech.create(model="tts-1", voice=voice, input=text)
-        response.stream_to_file(output_path)
-        audio = AudioSegment.from_file(output_path)
-        if self._save:
-            print(f"Audio saved to {output_path}")
-        else:
-            os.remove(output_path)
+        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

@@ -1,60 +1,22 @@
 import io
 import os
 
-import stability_sdk.interfaces.gooseai.generation.generation_pb2 as generation
+import torch
+from diffusers import DiffusionPipeline
 from PIL import Image
-from stability_sdk import client
 
+TEXT_TO_IMAGE_MODEL = "stabilityai/stable-diffusion-xl-base-1.0"
 
-class TextToImage:
-    def __init__(
-        self,
-        stability_key: str | None = None,
-        engine: str = "stable-diffusion-xl-1024-v1-0",
-        verbose: bool = True,
-    ):
-        stability_key = stability_key or os.getenv("STABILITY_KEY")
-        if stability_key is None:
-            raise ValueError(
-                "API Key for stability is required. Please provide it as an argument"
-                " or set it as an environment variable `STABILITY_KEY`. "
-            )
-
-        self.client = client.StabilityInference(stability_key, verbose=verbose, engine=engine)
 
-    def generate_image(
-        self,
-        prompt: str,
-        width: int = 1024,
-        height: int = 1024,
-        steps: int = 30,
-        cfg_scale: float = 8.0,
-        seed: int = 1,
-    ) -> Image.Image:
-        answers = self.client.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,
-            safety=False,
-            samples=1,
-            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)
+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
         )
-        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}")
-        return img
+        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

@@ -10,13 +10,12 @@ IMAGE_TO_VIDEO_MODEL = "stabilityai/stable-video-diffusion-img2vid-xt"
 
 
 class TextToVideo:
-    def __init__(self, gpu_optimized: bool = True):
-        self.pipeline = DiffusionPipeline.from_pretrained(
-            TEXT_TO_VIDEO_MODEL, torch_dtype=torch.float16 if gpu_optimized else torch.float32
-        )
+    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)
-        if gpu_optimized:
-            self.pipeline.enable_model_cpu_offload()
+        self.pipeline.to("cuda")
 
     def generate_video(
         self, prompt: str, num_steps: int = 25, height: int = 320, width: int = 576, num_frames: int = 24
@@ -39,7 +38,6 @@ class ImageToVideo:
         self.pipeline = DiffusionPipeline.from_pretrained(
             IMAGE_TO_VIDEO_MODEL, torch_dtype=torch.float16, variant="fp16"
         ).to("cuda")
-        self.pipeline.enable_model_cpu_offload()
 
     def generate_video(self, image: Image, fps: int = 24) -> Video:
         video_frames = self.pipeline(image=image, fps=fps, output_type="np").frames[0]

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.3.dist-info → videopython-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: videopython
-Version: 0.1.3
+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
@@ -211,13 +211,22 @@ License-File: LICENSE
 Requires-Dist: click >=8.1.7
 Requires-Dist: numpy >=1.25.2
 Requires-Dist: opencv-python >=4.9.0.80
-Requires-Dist: pytest >=7.4.0
-Requires-Dist: transformers >=4.38.1
-Requires-Dist: diffusers >=0.26.3
-Requires-Dist: torch >=2.1.0
-Requires-Dist: stability-sdk >=0.8.5
-Requires-Dist: openai ==1.3.5
+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.3.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-0.1.3.dist-info/RECORD

@@ -1,17 +0,0 @@
-videopython/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-videopython/base/compose.py,sha256=pti12VY3Yg7TZZiENPF6veM8POWssfsK8ePDdGlhAhA,1968
-videopython/base/effects.py,sha256=DpA8V89Es7YWPEq72l_h_D7MG1QYf1iuslAl-QgzZx8,2153
-videopython/base/transforms.py,sha256=DQcG8tZ8nlGj3khlp3v4C0MISpRY2rZr-6B6GtPZykE,4251
-videopython/base/transitions.py,sha256=efuJdls2xJVpXV8RGaFd--ii8cLUPz6FdmhSvOjaiTM,2275
-videopython/base/video.py,sha256=40leF8bSjNIhP_L8loOh9ptlZNTZAZ95Dgv9FH4mSz4,10791
-videopython/generation/__init__.py,sha256=Qse024UgiS9OxXzbbInyZ-9cpfI4enR2Dcds4lLDpNA,201
-videopython/generation/audio.py,sha256=YPqUdAcB0mGCt0mgFrxzupX08xx0O_qwfVdjFGlAxaw,985
-videopython/generation/image.py,sha256=B-TlrNXFu18NnMi3KO5fjk0paTSmIsQk400iZb76K8w,2507
-videopython/generation/video.py,sha256=4P4DhHS-_eDColsXK6YefSdoQbU3Ce0n6fHuY5zewYI,1874
-videopython/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-videopython/utils/common.py,sha256=F-30YoKUwWDI7HiJUWw0gRFUguhShSVaxT0aFfvpifg,936
-videopython-0.1.3.dist-info/LICENSE,sha256=nJL9jVOt2MSW7swNDq4Y6oD_n9bLI0B0afr8ougtZ6s,10832
-videopython-0.1.3.dist-info/METADATA,sha256=xj8k5j3qPIVKgXbr4uTi6ad2BSs9j6-V6baonpQKoJI,14709
-videopython-0.1.3.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-videopython-0.1.3.dist-info/top_level.txt,sha256=OikTGG8Swfw_syz--1atAn5KQ4GH9Pye17eATGred-Q,12
-videopython-0.1.3.dist-info/RECORD,,