videopython 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

videopython/base/transitions.py

@@ -67,7 +67,7 @@ class FadeTransition(Transition):
             ],
             fps=video_fps,
         )
-        faded_videos.audio = videos[0].audio.append(videos[1].audio, crossfade=(effect_time_fps / video_fps) * 1000)
+        faded_videos.audio = videos[0].audio.concat(videos[1].audio, crossfade=(effect_time_fps / video_fps))
         return faded_videos
 
 
@@ -102,5 +102,5 @@ class BlurTransition(Transition):
             ],
             fps=video_fps,
         )
-        blurred_videos.audio = videos[0].audio.append(videos[1].audio)
+        blurred_videos.audio = videos[0].audio.concat(videos[1].audio)
         return blurred_videos

videopython/base/video.py

@@ -1,15 +1,18 @@
 from __future__ import annotations
 
-import shlex
 import subprocess
+import tempfile
 from dataclasses import dataclass
 from pathlib import Path
+from typing import Literal, get_args
 
 import cv2
 import numpy as np
-from pydub import AudioSegment
+from soundpython import Audio
 
-from videopython.utils.common import check_path, generate_random_name
+from videopython.utils.common import generate_random_name
+
+ALLOWED_VIDEO_FORMATS = Literal["mp4", "avi", "mov", "mkv", "webm"]
 
 
 @dataclass
@@ -38,11 +41,7 @@ class VideoMetadata:
 
     @classmethod
     def from_path(cls, video_path: str) -> VideoMetadata:
-        """Creates VideoMetadata object from video file.
-
-        Args:
-            video_path: Path to video file.
-        """
+        """Creates VideoMetadata object from video file."""
         video = cv2.VideoCapture(video_path)
         frame_count = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
         fps = round(video.get(cv2.CAP_PROP_FPS), 2)
@@ -60,13 +59,7 @@ class VideoMetadata:
 
     @classmethod
     def from_video(cls, video: Video) -> VideoMetadata:
-        """Creates VideoMetadata object from frames.
-
-        Args:
-            frames: Frames of the video.
-            fps: Frames per second of the video.
-        """
-
+        """Creates VideoMetadata object from Video instance."""
         frame_count, height, width, _ = video.frames.shape
         total_seconds = round(frame_count / video.fps, 2)
 
@@ -112,11 +105,14 @@ class Video:
     def from_path(cls, path: str) -> Video:
         new_vid = cls()
         new_vid.frames, new_vid.fps = cls._load_video_from_path(path)
-        audio = cls._load_audio_from_path(path)
-        if not audio:
+
+        try:
+            new_vid.audio = Audio.from_file(path)
+        except Exception as e:
             print(f"No audio found for `{path}`, adding silent track!")
-            audio = AudioSegment.silent(duration=round(new_vid.total_seconds * 1000))
-        new_vid.audio = audio
+            new_vid.audio = Audio.create_silent(
+                duration_seconds=round(new_vid.total_seconds, 2), stereo=True, sample_rate=44100
+            )
         return new_vid
 
     @classmethod
@@ -130,7 +126,9 @@ class Video:
             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))
+        new_vid.audio = Audio.create_silent(
+            duration_seconds=round(new_vid.total_seconds, 2), stereo=True, sample_rate=44100
+        )
         return new_vid
 
     @classmethod
@@ -140,12 +138,12 @@ 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=round(new_vid.total_seconds * 1000))
+        new_vid.audio = Audio.create_silent(duration_seconds=length_seconds, stereo=True, sample_rate=44100)
         return new_vid
 
     def copy(self) -> Video:
         copied = Video().from_frames(self.frames.copy(), self.fps)
-        copied.audio = self.audio
+        copied.audio = self.audio  # Audio objects are immutable, no need to copy
         return copied
 
     def is_loaded(self) -> bool:
@@ -161,87 +159,126 @@ class Video:
             self.from_frames(self.frames[:frame_idx], self.fps),
             self.from_frames(self.frames[frame_idx:], self.fps),
         )
-        audio_midpoint = (frame_idx / self.fps) * 1000
-        split_videos[0].audio = self.audio[:audio_midpoint]
-        split_videos[1].audio = self.audio[audio_midpoint:]
-        return split_videos
-
-    def save(self, filename: str | None = None) -> str:
-        """Saves the video.
-
-        Args:
-            filename: Name of the output video file. Generates random UUID name if not provided.
-        """
-        if not self.is_loaded():
-            raise RuntimeError(f"Video is not loaded, cannot save!")
 
-        if filename is None:
-            filename = generate_random_name(suffix=".mp4")
-        filename = check_path(filename, dir_exists=True, suffix=".mp4")
+        # Split audio at the corresponding time point
+        split_time = frame_idx / self.fps
+        split_videos[0].audio = self.audio.slice(start_seconds=0, end_seconds=split_time)
+        split_videos[1].audio = self.audio.slice(start_seconds=split_time)
 
-        ffmpeg_video_command = (
-            f"ffmpeg -loglevel error -y -framerate {self.fps} -f rawvideo -pix_fmt rgb24"
-            f" -s {self.metadata.width}x{self.metadata.height} "
-            f"-i pipe:0 -c:v libx264 -pix_fmt yuv420p {filename}"
-        )
+        return split_videos
 
-        ffmpeg_audio_command = (
-            f"ffmpeg -loglevel error -y -i {filename} -f s16le -acodec pcm_s16le "
-            f"-ar {self.audio.frame_rate} -ac {self.audio.channels} -i pipe:0 "
-            f"-c:v copy -c:a aac -strict experimental {filename}_temp.mp4"
-        )
+    def save(self, filename: str | Path | None = None, format: ALLOWED_VIDEO_FORMATS = "mp4") -> Path:
+        if not self.is_loaded():
+            raise RuntimeError("Video is not loaded, cannot save!")
 
-        try:
-            print("Saving frames to video...")
-            subprocess.run(
-                ffmpeg_video_command,
-                input=self.frames.tobytes(),
-                check=True,
-                shell=True,
+        if format.lower() not in get_args(ALLOWED_VIDEO_FORMATS):
+            raise ValueError(
+                f"Unsupported format: {format}. Allowed formats are: {', '.join(get_args(ALLOWED_VIDEO_FORMATS))}"
             )
-        except subprocess.CalledProcessError as e:
-            print("Error saving frames to video!")
-            raise e
 
-        try:
-            print("Adding audio track...")
-            subprocess.run(ffmpeg_audio_command, input=self.audio.raw_data, check=True, shell=True)
-            Path(filename).unlink()
-            Path(filename + "_temp.mp4").rename(filename)
-        except subprocess.CalledProcessError as e:
-            print(f"Error adding audio track!")
-            raise e
-
-        print(f"Video saved into `{filename}`!")
-        return filename
-
-    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 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[: round(self.total_seconds * 1000)]
-
-        if overlay:
-            self.audio = self.audio.overlay(new_audio, loop=loop, gain_during_overlay=overlay_gain)
+        if filename is None:
+            filename = Path(generate_random_name(suffix=f".{format}"))
+        else:
+            filename = Path(filename).with_suffix(f".{format}")
+            filename.parent.mkdir(parents=True, exist_ok=True)
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_dir_path = Path(temp_dir)
+
+            # Save frames as images
+            for i, frame in enumerate(self.frames):
+                frame_path = temp_dir_path / f"frame_{i:04d}.png"
+                cv2.imwrite(str(frame_path), cv2.cvtColor(frame, cv2.COLOR_RGB2BGR))
+
+            # Calculate exact video duration
+            video_duration = len(self.frames) / self.fps
+
+            # Ensure audio duration matches video duration
+            if (
+                abs(self.audio.metadata.duration_seconds - video_duration) > 0.001
+            ):  # Small threshold for float comparison
+                if self.audio.metadata.duration_seconds < video_duration:
+                    # Create silent audio for the remaining duration
+                    remaining_duration = video_duration - self.audio.metadata.duration_seconds
+                    silent_audio = Audio.create_silent(
+                        duration_seconds=remaining_duration,
+                        stereo=(self.audio.metadata.channels == 2),
+                        sample_rate=self.audio.metadata.sample_rate,
+                        sample_width=self.audio.metadata.sample_width,
+                    )
+                    # Concatenate original audio with silent padding
+                    padded_audio = self.audio.concat(silent_audio)
+                else:
+                    # Trim audio to match video duration
+                    padded_audio = self.audio.slice(end_seconds=video_duration)
+            else:
+                padded_audio = self.audio
+
+            # Save audio to temporary WAV file
+            temp_audio = temp_dir_path / "temp_audio.wav"
+            padded_audio.save(str(temp_audio), format="wav")
+
+            # Construct FFmpeg command with explicit duration
+            ffmpeg_command = [
+                "ffmpeg",
+                "-y",
+                "-framerate",
+                str(self.fps),  # Use -framerate instead of -r for input
+                "-i",
+                str(temp_dir_path / "frame_%04d.png"),
+                "-i",
+                str(temp_audio),
+                "-c:v",
+                "libx264",
+                "-preset",
+                "medium",
+                "-crf",
+                "23",
+                "-c:a",
+                "aac",  # Use AAC instead of copy for more reliable audio
+                "-b:a",
+                "192k",
+                "-pix_fmt",
+                "yuv420p",
+                "-map",
+                "0:v:0",  # Map video from first input
+                "-map",
+                "1:a:0",  # Map audio from second input
+                "-vsync",
+                "cfr",  # Force constant frame rate
+                str(filename),
+            ]
+
+            try:
+                subprocess.run(ffmpeg_command, check=True, capture_output=True, text=True)
+                return filename
+            except subprocess.CalledProcessError as e:
+                print(f"Error saving video: {e}")
+                print(f"FFmpeg stderr: {e.stderr}")
+                raise
+
+    def add_audio(self, audio: Audio, overlay: bool = True) -> None:
+        if self.audio.is_silent:
+            self.audio = audio
+        elif overlay:
+            self.audio = self.audio.overlay(audio, position=0.0)
         else:
-            self.audio = new_audio
+            self.audio = audio
+
+    def add_audio_from_file(self, path: str, overlay: bool = True) -> None:
+        try:
+            new_audio = Audio.from_file(path)
+            self.add_audio(new_audio, overlay)
+        except Exception as e:
+            print(f"Audio file `{path}` not found or invalid, skipping!")
 
     def __add__(self, other: Video) -> Video:
-        # TODO: Should it be class method? How to make it work with sum()?
         if self.fps != other.fps:
             raise ValueError("FPS of videos do not match!")
         elif self.frame_shape != other.frame_shape:
-            raise ValueError(
-                "Resolutions of the images do not match: "
-                f"{self.frame_shape} not compatible with {other.frame_shape}."
-            )
+            raise ValueError(f"Resolutions do not match: {self.frame_shape} vs {other.frame_shape}")
         new_video = self.from_frames(np.r_["0,2", self.frames, other.frames], fps=self.fps)
-        new_video.audio = self.audio + other.audio
+        new_video.audio = self.audio.concat(other.audio)
         return new_video
 
     def __str__(self) -> str:
@@ -251,65 +288,58 @@ class Video:
         if not isinstance(val, slice):
             raise ValueError("Only slices are supported for video indexing!")
 
-        # Sub-slice video if given a slice
+        # Sub-slice video frames
         sliced = self.from_frames(self.frames[val], fps=self.fps)
-        # Handle slicing without value for audio
+
+        # Handle slicing bounds 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:
-        try:
-            audio = AudioSegment.from_file(path)
-            return audio
-        except IndexError:
-            return None
+        # Slice audio to match video duration
+        audio_start = start / self.fps
+        audio_end = stop / self.fps
+        sliced.audio = self.audio.slice(start_seconds=audio_start, end_seconds=audio_end)
+        return sliced
 
     @staticmethod
     def _load_video_from_path(path: str) -> tuple[np.ndarray, float]:
-        """Loads frames and fps information from video file.
+        cap = cv2.VideoCapture(path)
+        if not cap.isOpened():
+            raise ValueError(f"Unable to open video file: {path}")
 
-        Args:
-            path: Path to video file.
-        """
-        metadata = VideoMetadata.from_path(path)
-        ffmpeg_command = f"ffmpeg -i {path} -f rawvideo -pix_fmt rgb24 -loglevel quiet pipe:1"
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        frames = []
+
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                break
+            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            frames.append(frame)
+
+        cap.release()
 
-        # Run the ffmpeg command and capture the stdout
-        ffmpeg_process = subprocess.Popen(shlex.split(ffmpeg_command), stdout=subprocess.PIPE)
-        ffmpeg_out, _ = ffmpeg_process.communicate()
+        if not frames:
+            raise ValueError(f"No frames could be read from the video file: {path}")
 
-        # Convert the raw video data to a NumPy array
-        frames = np.frombuffer(ffmpeg_out, dtype=np.uint8).reshape([-1, metadata.height, metadata.width, 3])
-        fps = metadata.fps
-        return frames, fps
+        return np.array(frames), fps
 
     @property
     def video_shape(self) -> tuple[int, int, int, int]:
-        """Returns 4D video shape."""
         return self.frames.shape
 
     @property
     def frame_shape(self) -> tuple[int, int, int]:
-        """Returns 3D frame shape."""
         return self.frames.shape[1:]
 
     @property
     def total_seconds(self) -> float:
-        """Returns total seconds of the video."""
         return round(self.frames.shape[0] / self.fps, 4)
 
     @property
     def metadata(self) -> VideoMetadata:
-        """Returns VideoMetadata object."""
         return VideoMetadata.from_video(self)

videopython/generation/__init__.py

@@ -1,4 +1,4 @@
-from .audio import TextToSpeech
+from .audio import TextToMusic, TextToSpeech
 from .image import TextToImage
 from .video import ImageToVideo, TextToVideo
 
@@ -7,4 +7,5 @@ __all__ = [
     "TextToSpeech",
     "TextToImage",
     "TextToVideo",
+    "TextToMusic",
 ]

videopython/generation/audio.py

@@ -1,9 +1,14 @@
-import numpy as np
 import torch
-from pydub import AudioSegment
-from transformers import AutoTokenizer, VitsModel
+from soundpython import Audio, AudioMetadata
+from transformers import (
+    AutoProcessor,
+    AutoTokenizer,
+    MusicgenForConditionalGeneration,
+    VitsModel,
+)
 
 TEXT_TO_SPEECH_MODEL = "facebook/mms-tts-eng"
+MUSIC_GENERATION_MODEL_SMALL = "facebook/musicgen-small"
 
 
 class TextToSpeech:
@@ -11,12 +16,53 @@ class TextToSpeech:
         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:
+    def generate_audio(self, text: str) -> Audio:
         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
+        # Convert to float32 and normalize to [-1, 1]
+        audio_data = output.T.float().numpy()
+
+        metadata = AudioMetadata(
+            sample_rate=self.pipeline.config.sampling_rate,
+            channels=1,
+            sample_width=4,
+            duration_seconds=len(audio_data) / self.pipeline.config.sampling_rate,
+            frame_count=len(audio_data),
+        )
+
+        return Audio(audio_data, metadata)
+
+
+class TextToMusic:
+    def __init__(self) -> None:
+        """
+        Generates music from text using the Musicgen model.
+        Check the license for the model before using it.
+        """
+        self.processor = AutoProcessor.from_pretrained(MUSIC_GENERATION_MODEL_SMALL)
+        self.model = MusicgenForConditionalGeneration.from_pretrained(MUSIC_GENERATION_MODEL_SMALL)
+
+    def generate_audio(self, text: str, max_new_tokens: int) -> Audio:
+        inputs = self.processor(
+            text=[text],
+            padding=True,
+            return_tensors="pt",
+        )
+        audio_values = self.model.generate(**inputs, max_new_tokens=max_new_tokens)
+        sampling_rate = self.model.config.audio_encoder.sampling_rate
+
+        # Convert to float32 and normalize to [-1, 1]
+        audio_data = audio_values[0, 0].float().numpy()
+
+        metadata = AudioMetadata(
+            sample_rate=sampling_rate,
+            channels=1,
+            sample_width=4,
+            duration_seconds=len(audio_data) / sampling_rate,
+            frame_count=len(audio_data),
+        )
+
+        return Audio(audio_data, metadata)

videopython/utils/image.py

@@ -197,6 +197,10 @@ class ImageText:
             # 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)
+            if not isinstance(text_mask, np.ndarray):
+                raise TypeError(
+                    f"The returned text mask is of type {type(text_mask)}, " "but it should be numpy array!"
+                )
             xmin, xmax, ymin, ymax = self._find_smallest_bounding_rect(text_mask)
             # Get global bounding box position
             xmin += x - background_padding

videopython-0.3.0.dist-info/METADATA

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: videopython
+Version: 0.3.0
+Summary: Minimal video generation and processing library.
+Project-URL: Homepage, https://github.com/bartwojtowicz/videopython/
+Project-URL: Repository, https://github.com/bartwojtowicz/videopython/
+Project-URL: Documentation, https://github.com/bartwojtowicz/videopython/
+Author-email: Bartosz Wójtowicz <bartoszwojtowicz@outlook.com>, Bartosz Rudnikowicz <bartoszrudnikowicz840@gmail.com>, Piotr Pukisz <piotr.pukisz@gmail.com>
+License: Apache-2.0
+License-File: LICENSE
+Keywords: editing,generation,movie,opencv,python,video,videopython
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: <3.13,>=3.10
+Requires-Dist: numpy>=1.25.2
+Requires-Dist: opencv-python>=4.9.0.80
+Requires-Dist: pillow>=10.3.0
+Requires-Dist: pydub>=0.25.1
+Requires-Dist: soundpython>=0.1.9
+Requires-Dist: tqdm>=4.66.3
+Description-Content-Type: text/markdown
+
+# About
+
+Minimal video generation and processing library.
+
+## Setup 
+
+### Install ffmpeg
+```bash
+# Install with brew for MacOS:
+brew install ffmpeg
+# Install with apt-get for Ubuntu:
+sudo apt-get install ffmpeg
+```
+
+### Install with pip
+```bash
+pip install videopython[generation]
+```
+> You can install without `[generation]` dependencies for basic video handling and processing. 
+> The funcionalities found in `videopython.generation` won't work.
+
+## Basic Usage
+
+### Video handling
+
+```python
+from videopython.base.video import Video
+
+# Load videos and print metadata
+video1 = Video.from_path("tests/test_data/fast_benchmark.mp4")
+print(video1)
+
+video2 = Video.from_path("tests/test_data/slow_benchmark.mp4")
+print(video2)
+
+# Define the transformations
+from videopython.base.transforms import CutSeconds, ResampleFPS, Resize, TransformationPipeline
+
+pipeline = TransformationPipeline(
+    [CutSeconds(start=1.5, end=6.5), ResampleFPS(fps=30), Resize(width=1000, height=1000)]
+)
+video1 = pipeline.run(video1)
+video2 = pipeline.run(video2)
+
+# Combine videos, add audio and save
+from videopython.base.transitions import FadeTransition
+
+fade = FadeTransition(effect_time_seconds=3.0)
+video = fade.apply(videos=(video1, video2))
+video.add_audio_from_file("tests/test_data/test_audio.mp3")
+
+savepath = video.save()
+```
+
+### Video Generation
+
+> Using Nvidia A40 or better is recommended for the `videopython.generation` module.
+```python
+# Generate image and animate it
+from videopython.generation import ImageToVideo
+from videopython.generation import TextToImage
+from videopython.generation import TextToMusic
+
+image = TextToImage().generate_image(prompt="Golden Retriever playing in the park")
+video = ImageToVideo().generate_video(image=image, fps=24)
+
+# Video generation directly from prompt
+from videopython.generation import TextToVideo
+video_gen = TextToVideo()
+video = video_gen.generate_video("Dogs playing in the snow")
+for _ in range(10):
+    video += video_gen.generate_video("Dogs playing in the snow")
+
+# Cut the first 2 seconds
+from videopython.base.transforms import CutSeconds
+transformed_video = CutSeconds(start_second=0, end_second=2).apply(video.copy())
+
+# Upsample to 30 FPS
+from videopython.base.transforms import ResampleFPS
+transformed_video = ResampleFPS(new_fps=30).apply(transformed_video)
+
+# Resize to 1000x1000
+from videopython.base.transforms import Resize
+transformed_video = Resize(width=1000, height=1000).apply(transformed_video)
+
+# Add generated music
+# MusicGen cannot generate more than 1503 tokens (~30seconds of audio)
+text_to_music = TextToMusic()
+audio = text_to_music.generate_audio("Happy dogs playing together in a park", max_new_tokens=256)
+transformed_video.add_audio(audio=audio)
+
+filepath = transformed_video.save()
+```

videopython-0.3.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+videopython/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+videopython/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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/exceptions.py,sha256=68_16lUPOR9_zhWdeBGS8_NFI32VbrcoDbN5KHHg0_w,44
+videopython/base/transforms.py,sha256=VP8SGArokfXN-IE7tk-3i0oMM3HV5zpJa-GLj7BoeRo,5856
+videopython/base/transitions.py,sha256=P1bBsxugf5i0JEtx7MoRgxWSIDcBli-0QucRwBIFGqs,3687
+videopython/base/video.py,sha256=8hIIr-LzLktuPpNG3IvuqhSSDwT0jXbQmpv9wo7TMhc,12304
+videopython/generation/__init__.py,sha256=5esJ7_PPSkqNXuPQWLLAyeQZY00BnYFc94WZIHi7pBU,233
+videopython/generation/audio.py,sha256=CNf6ZeV3iU4CU0Kq8HtDLwLPP2ABq9AGQD1TBOSLyoQ,2230
+videopython/generation/image.py,sha256=i8zJm0WXn_Pykby9Urw1kzDcla6ArYhRgG-ueRdoAJ0,675
+videopython/generation/video.py,sha256=206YON_XjPTYyjIJ3j5uBgd_yHmCDg7SqbkIU9GzEgw,1831
+videopython/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+videopython/utils/common.py,sha256=F-30YoKUwWDI7HiJUWw0gRFUguhShSVaxT0aFfvpifg,936
+videopython/utils/image.py,sha256=MAncPG_vY4ZnewIsjgkCCzKJm2XtZXPiNRv3Zyc0AYM,12298
+videopython-0.3.0.dist-info/METADATA,sha256=YvNIxT652bGaoNbob_vrXVg9SJxnbpudCKkbdTfNfJo,3879
+videopython-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+videopython-0.3.0.dist-info/licenses/LICENSE,sha256=nJL9jVOt2MSW7swNDq4Y6oD_n9bLI0B0afr8ougtZ6s,10832
+videopython-0.3.0.dist-info/RECORD,,

{videopython-0.2.0.dist-info → videopython-0.3.0.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.1.1)
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any
-

videopython/generation/pipeline.py

@@ -1,32 +0,0 @@
-import cv2
-import numpy as np
-from PIL import Image
-
-from videopython.base.transforms import Resize
-from videopython.generation import ImageToVideo, TextToImage
-
-N_ITERATIONS = 11
-PRMOPT = "Sunset at the sea, cimenatic view"
-
-
-def main():
-    text_to_image = TextToImage()
-    image_to_video = ImageToVideo()
-
-    target_height = 576
-    target_width = 1024
-
-    base_image = text_to_image.generate_image(PRMOPT)
-    image = cv2.resize(np.asarray(base_image), (target_width, target_height))
-
-    video = image_to_video.generate_video(image)
-
-    for i in range(N_ITERATIONS - 1):
-        print(f"Generating {i+2}/{N_ITERATIONS}...")
-        video += image_to_video.generate_video(Image.fromarray(video.frames[-1]))
-
-    video.save()
-
-
-if __name__ == "__main__":
-    main()

videopython-0.2.0.dist-info/METADATA

@@ -1,316 +0,0 @@
-Metadata-Version: 2.1
-Name: videopython
-Version: 0.2.0
-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
-                                   Version 2.0, January 2004
-                                http://www.apache.org/licenses/
-        
-           TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-        
-           1. Definitions.
-        
-              "License" shall mean the terms and conditions for use, reproduction,
-              and distribution as defined by Sections 1 through 9 of this document.
-        
-              "Licensor" shall mean the copyright owner or entity authorized by
-              the copyright owner that is granting the License.
-        
-              "Legal Entity" shall mean the union of the acting entity and all
-              other entities that control, are controlled by, or are under common
-              control with that entity. For the purposes of this definition,
-              "control" means (i) the power, direct or indirect, to cause the
-              direction or management of such entity, whether by contract or
-              otherwise, or (ii) ownership of fifty percent (50%) or more of the
-              outstanding shares, or (iii) beneficial ownership of such entity.
-        
-              "You" (or "Your") shall mean an individual or Legal Entity
-              exercising permissions granted by this License.
-        
-              "Source" form shall mean the preferred form for making modifications,
-              including but not limited to software source code, documentation
-              source, and configuration files.
-        
-              "Object" form shall mean any form resulting from mechanical
-              transformation or translation of a Source form, including but
-              not limited to compiled object code, generated documentation,
-              and conversions to other media types.
-        
-              "Work" shall mean the work of authorship, whether in Source or
-              Object form, made available under the License, as indicated by a
-              copyright notice that is included in or attached to the work
-              (an example is provided in the Appendix below).
-        
-              "Derivative Works" shall mean any work, whether in Source or Object
-              form, that is based on (or derived from) the Work and for which the
-              editorial revisions, annotations, elaborations, or other modifications
-              represent, as a whole, an original work of authorship. For the purposes
-              of this License, Derivative Works shall not include works that remain
-              separable from, or merely link (or bind by name) to the interfaces of,
-              the Work and Derivative Works thereof.
-        
-              "Contribution" shall mean any work of authorship, including
-              the original version of the Work and any modifications or additions
-              to that Work or Derivative Works thereof, that is intentionally
-              submitted to Licensor for inclusion in the Work by the copyright owner
-              or by an individual or Legal Entity authorized to submit on behalf of
-              the copyright owner. For the purposes of this definition, "submitted"
-              means any form of electronic, verbal, or written communication sent
-              to the Licensor or its representatives, including but not limited to
-              communication on electronic mailing lists, source code control systems,
-              and issue tracking systems that are managed by, or on behalf of, the
-              Licensor for the purpose of discussing and improving the Work, but
-              excluding communication that is conspicuously marked or otherwise
-              designated in writing by the copyright owner as "Not a Contribution."
-        
-              "Contributor" shall mean Licensor and any individual or Legal Entity
-              on behalf of whom a Contribution has been received by Licensor and
-              subsequently incorporated within the Work.
-        
-           2. Grant of Copyright License. Subject to the terms and conditions of
-              this License, each Contributor hereby grants to You a perpetual,
-              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-              copyright license to reproduce, prepare Derivative Works of,
-              publicly display, publicly perform, sublicense, and distribute the
-              Work and such Derivative Works in Source or Object form.
-        
-           3. Grant of Patent License. Subject to the terms and conditions of
-              this License, each Contributor hereby grants to You a perpetual,
-              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-              (except as stated in this section) patent license to make, have made,
-              use, offer to sell, sell, import, and otherwise transfer the Work,
-              where such license applies only to those patent claims licensable
-              by such Contributor that are necessarily infringed by their
-              Contribution(s) alone or by combination of their Contribution(s)
-              with the Work to which such Contribution(s) was submitted. If You
-              institute patent litigation against any entity (including a
-              cross-claim or counterclaim in a lawsuit) alleging that the Work
-              or a Contribution incorporated within the Work constitutes direct
-              or contributory patent infringement, then any patent licenses
-              granted to You under this License for that Work shall terminate
-              as of the date such litigation is filed.
-        
-           4. Redistribution. You may reproduce and distribute copies of the
-              Work or Derivative Works thereof in any medium, with or without
-              modifications, and in Source or Object form, provided that You
-              meet the following conditions:
-        
-              (a) You must give any other recipients of the Work or
-                  Derivative Works a copy of this License; and
-        
-              (b) You must cause any modified files to carry prominent notices
-                  stating that You changed the files; and
-        
-              (c) You must retain, in the Source form of any Derivative Works
-                  that You distribute, all copyright, patent, trademark, and
-                  attribution notices from the Source form of the Work,
-                  excluding those notices that do not pertain to any part of
-                  the Derivative Works; and
-        
-              (d) If the Work includes a "NOTICE" text file as part of its
-                  distribution, then any Derivative Works that You distribute must
-                  include a readable copy of the attribution notices contained
-                  within such NOTICE file, excluding those notices that do not
-                  pertain to any part of the Derivative Works, in at least one
-                  of the following places: within a NOTICE text file distributed
-                  as part of the Derivative Works; within the Source form or
-                  documentation, if provided along with the Derivative Works; or,
-                  within a display generated by the Derivative Works, if and
-                  wherever such third-party notices normally appear. The contents
-                  of the NOTICE file are for informational purposes only and
-                  do not modify the License. You may add Your own attribution
-                  notices within Derivative Works that You distribute, alongside
-                  or as an addendum to the NOTICE text from the Work, provided
-                  that such additional attribution notices cannot be construed
-                  as modifying the License.
-        
-              You may add Your own copyright statement to Your modifications and
-              may provide additional or different license terms and conditions
-              for use, reproduction, or distribution of Your modifications, or
-              for any such Derivative Works as a whole, provided Your use,
-              reproduction, and distribution of the Work otherwise complies with
-              the conditions stated in this License.
-        
-           5. Submission of Contributions. Unless You explicitly state otherwise,
-              any Contribution intentionally submitted for inclusion in the Work
-              by You to the Licensor shall be under the terms and conditions of
-              this License, without any additional terms or conditions.
-              Notwithstanding the above, nothing herein shall supersede or modify
-              the terms of any separate license agreement you may have executed
-              with Licensor regarding such Contributions.
-        
-           6. Trademarks. This License does not grant permission to use the trade
-              names, trademarks, service marks, or product names of the Licensor,
-              except as required for reasonable and customary use in describing the
-              origin of the Work and reproducing the content of the NOTICE file.
-        
-           7. Disclaimer of Warranty. Unless required by applicable law or
-              agreed to in writing, Licensor provides the Work (and each
-              Contributor provides its Contributions) on an "AS IS" BASIS,
-              WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-              implied, including, without limitation, any warranties or conditions
-              of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-              PARTICULAR PURPOSE. You are solely responsible for determining the
-              appropriateness of using or redistributing the Work and assume any
-              risks associated with Your exercise of permissions under this License.
-        
-           8. Limitation of Liability. In no event and under no legal theory,
-              whether in tort (including negligence), contract, or otherwise,
-              unless required by applicable law (such as deliberate and grossly
-              negligent acts) or agreed to in writing, shall any Contributor be
-              liable to You for damages, including any direct, indirect, special,
-              incidental, or consequential damages of any character arising as a
-              result of this License or out of the use or inability to use the
-              Work (including but not limited to damages for loss of goodwill,
-              work stoppage, computer failure or malfunction, or any and all
-              other commercial damages or losses), even if such Contributor
-              has been advised of the possibility of such damages.
-        
-           9. Accepting Warranty or Additional Liability. While redistributing
-              the Work or Derivative Works thereof, You may choose to offer,
-              and charge a fee for, acceptance of support, warranty, indemnity,
-              or other liability obligations and/or rights consistent with this
-              License. However, in accepting such obligations, You may act only
-              on Your own behalf and on Your sole responsibility, not on behalf
-              of any other Contributor, and only if You agree to indemnify,
-              defend, and hold each Contributor harmless for any liability
-              incurred by, or claims asserted against, such Contributor by reason
-              of your accepting any such warranty or additional liability.
-        
-           END OF TERMS AND CONDITIONS
-        
-           Copyright 2023 Bartosz Wójtowicz
-           Copyright 2023 Bartosz Rudnikowicz
-           Copyright 2023 Piotr Pukisz
-        
-           Licensed under the Apache License, Version 2.0 (the "License");
-           you may not use this file except in compliance with the License.
-           You may obtain a copy of the License at
-        
-               http://www.apache.org/licenses/LICENSE-2.0
-        
-           Unless required by applicable law or agreed to in writing, software
-           distributed under the License is distributed on an "AS IS" BASIS,
-           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-           See the License for the specific language governing permissions and
-           limitations under the 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: 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
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.10
-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.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
-
-Minimal video generation and processing library.
-
-## Setup 
-
-### Install ffmpeg
-```bash
-# Install with brew for MacOS:
-brew install ffmpeg
-# Install with apt-get for Ubuntu:
-sudo apt-get install ffmpeg
-```
-
-### Install with pip
-```bash
-pip install videopython[generation]
-```
-> You can install without `[generation]` dependencies for basic video handling and processing. 
-> The funcionalities found in `videopython.generation` won't work.
-
-## Basic Usage
-
-### Video handling
-
-```python
-from videopython.base.video import Video
-
-# Load videos and print metadata
-video1 = Video.from_path("tests/test_data/fast_benchmark.mp4")
-print(video1)
-
-video2 = Video.from_path("tests/test_data/slow_benchmark.mp4")
-print(video2)
-
-# Define the transformations
-from videopython.base.transforms import CutSeconds, ResampleFPS, Resize, TransformationPipeline
-
-pipeline = TransformationPipeline(
-    [CutSeconds(start=1.5, end=6.5), ResampleFPS(fps=30), Resize(width=1000, height=1000)]
-)
-video1 = pipeline.run(video1)
-video2 = pipeline.run(video2)
-
-# Combine videos, add audio and save
-from videopython.base.transitions import FadeTransition
-
-fade = FadeTransition(effect_time_seconds=3.0)
-video = fade.apply(videos=(video1, video2))
-video.add_audio_from_file("tests/test_data/test_audio.mp3")
-
-savepath = video.save()
-```
-
-### Video Generation
-
-> Using Nvidia A40 or better is recommended for the `videopython.generation` module.
-```python
-# Generate image and animate it
-from videopython.generation import ImageToVideo
-from videopython.generation import TextToImage
-
-image = TextToImage().generate_image(prompt="Golden Retriever playing in the park")
-video = ImageToVideo().generate_video(image=image, fps=24)
-
-# Video generation directly from prompt
-from videopython.generation import TextToVideo
-video_gen = TextToVideo()
-video = video_gen.generate_video("Dogs playing in the snow")
-for _ in range(10):
-    video += video_gen.generate_video("Dogs playing in the snow")
-
-# Cut the first 2 seconds
-from videopython.base.transforms import CutSeconds
-transformed_video = CutSeconds(start_second=0, end_second=2).apply(video.copy())
-
-# Upsample to 30 FPS
-from videopython.base.transforms import ResampleFPS
-transformed_video = ResampleFPS(new_fps=30).apply(transformed_video)
-
-# Resize to 1000x1000
-from videopython.base.transforms import Resize
-transformed_video = Resize(width=1000, height=1000).apply(transformed_video)
-
-filepath = transformed_video.save()
-```

videopython-0.2.0.dist-info/RECORD

@@ -1,20 +0,0 @@
-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/exceptions.py,sha256=68_16lUPOR9_zhWdeBGS8_NFI32VbrcoDbN5KHHg0_w,44
-videopython/base/transforms.py,sha256=VP8SGArokfXN-IE7tk-3i0oMM3HV5zpJa-GLj7BoeRo,5856
-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/pipeline.py,sha256=v8GHkGNLErnQBjzNA8oem7fRv7YOx_NdduEC47kQkf0,773
-videopython/generation/video.py,sha256=206YON_XjPTYyjIJ3j5uBgd_yHmCDg7SqbkIU9GzEgw,1831
-videopython/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-videopython/utils/common.py,sha256=F-30YoKUwWDI7HiJUWw0gRFUguhShSVaxT0aFfvpifg,936
-videopython/utils/image.py,sha256=gng1by8ieYRVs1DlxHPMqYIPxKc1WWwBm8W5oASBKfY,12084
-videopython-0.2.0.dist-info/LICENSE,sha256=nJL9jVOt2MSW7swNDq4Y6oD_n9bLI0B0afr8ougtZ6s,10832
-videopython-0.2.0.dist-info/METADATA,sha256=W8FecvXP3eT7BSeUNjDKiykVPIrcwXsademTs9gl3MU,16531
-videopython-0.2.0.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
-videopython-0.2.0.dist-info/top_level.txt,sha256=OikTGG8Swfw_syz--1atAn5KQ4GH9Pye17eATGred-Q,12
-videopython-0.2.0.dist-info/RECORD,,

videopython-0.2.0.dist-info/top_level.txt

@@ -1 +0,0 @@
-videopython