videopython 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

videopython/base/text/transcription.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class TranscriptionWord:
+    start: float
+    end: float
+    word: str
+
+
+@dataclass
+class TranscriptionSegment:
+    start: float
+    end: float
+    text: str
+    words: list[TranscriptionWord]
+
+
+@dataclass
+class Transcription:
+    segments: list[TranscriptionSegment]
+
+    def offset(self, time: float) -> Transcription:
+        """Return a new Transcription with all timings offset by the provided time value."""
+        offset_segments = []
+
+        for segment in self.segments:
+            offset_words = []
+            for word in segment.words:
+                offset_words.append(TranscriptionWord(start=word.start + time, end=word.end + time, word=word.word))
+
+            offset_segments.append(
+                TranscriptionSegment(
+                    start=segment.start + time, end=segment.end + time, text=segment.text, words=offset_words
+                )
+            )
+
+        return Transcription(segments=offset_segments)
+
+    def standardize_segments(self, *, time: float | None = None, num_words: int | None = None) -> Transcription:
+        """Return a new Transcription with standardized segments.
+
+        Args:
+            time: Maximum duration in seconds for each segment
+            num_words: Exact number of words per segment
+
+        Raises:
+            ValueError: If both time and num_words are provided or if neither is provided
+        """
+        if (time is None) == (num_words is None):
+            raise ValueError("Exactly one of 'time' or 'num_words' must be provided")
+
+        if time is not None and time <= 0:
+            raise ValueError("Time must be positive")
+
+        if num_words is not None and num_words <= 0:
+            raise ValueError("Number of words must be positive")
+
+        # Collect all words from all segments
+        all_words = []
+        for segment in self.segments:
+            all_words.extend(segment.words)
+
+        if not all_words:
+            return Transcription(segments=[])
+
+        standardized_segments = []
+
+        if time is not None:
+            # Group words by time constraint
+            current_words = []
+            current_start = None
+
+            for word in all_words:
+                if current_start is None:
+                    current_start = word.start
+                    current_words = [word]
+                elif word.end - current_start <= time:
+                    current_words.append(word)
+                else:
+                    # Create segment from current words
+                    if current_words:
+                        segment_text = " ".join(w.word for w in current_words)
+                        standardized_segments.append(
+                            TranscriptionSegment(
+                                start=current_start,
+                                end=current_words[-1].end,
+                                text=segment_text,
+                                words=current_words.copy(),
+                            )
+                        )
+
+                    # Start new segment
+                    current_start = word.start
+                    current_words = [word]
+
+            # Add final segment
+            if current_words:
+                segment_text = " ".join(w.word for w in current_words)
+                standardized_segments.append(
+                    TranscriptionSegment(
+                        start=current_start,  # type: ignore
+                        end=current_words[-1].end,
+                        text=segment_text,
+                        words=current_words.copy(),
+                    )
+                )
+        elif num_words is not None:
+            # Group words by word count constraint
+            for i in range(0, len(all_words), num_words):
+                segment_words = all_words[i : i + num_words]
+                segment_text = " ".join(w.word for w in segment_words)
+                standardized_segments.append(
+                    TranscriptionSegment(
+                        start=segment_words[0].start, end=segment_words[-1].end, text=segment_text, words=segment_words
+                    )
+                )
+
+        return Transcription(segments=standardized_segments)

videopython/base/utils.py

@@ -0,0 +1,6 @@
+import uuid
+
+
+def generate_random_name(suffix=".mp4"):
+    """Generates random name."""
+    return f"{uuid.uuid4()}{suffix}"

videopython/base/video.py

@@ -11,7 +11,7 @@ from typing import Literal, get_args
 import numpy as np
 from soundpython import Audio
 
-from videopython.utils.common import generate_random_name
+from videopython.base.utils import generate_random_name
 
 ALLOWED_VIDEO_FORMATS = Literal["mp4", "avi", "mov", "mkv", "webm"]
 
@@ -134,15 +134,20 @@ class VideoMetadata:
 
 
 class Video:
-    def __init__(self):
-        self.fps = None
-        self.frames = None
-        self.audio = None
+    def __init__(self, frames: np.ndarray, fps: int | float, audio: Audio | None = None):
+        self.frames = frames
+        self.fps = fps
+        if audio:
+            self.audio = audio
+        else:
+            self.audio = Audio.create_silent(
+                duration_seconds=round(self.total_seconds, 2), stereo=True, sample_rate=44100
+            )
 
     @classmethod
-    def from_path(cls, path: str, read_batch_size: int = 100) -> Video:
-        new_vid = cls()
-
+    def from_path(
+        cls, path: str, read_batch_size: int = 100, start_second: float | None = None, end_second: float | None = None
+    ) -> Video:
         try:
             # Get video metadata using VideoMetadata.from_path
             metadata = VideoMetadata.from_path(path)
@@ -150,77 +155,154 @@ class Video:
             width = metadata.width
             height = metadata.height
             fps = metadata.fps
-            total_frames = metadata.frame_count
-
-            # Set up FFmpeg command for raw video extraction
-            ffmpeg_cmd = [
-                "ffmpeg",
-                "-i",
-                path,
-                "-f",
-                "rawvideo",
-                "-pix_fmt",
-                "rgb24",
-                "-vsync",
-                "0",
-                "-vcodec",
-                "rawvideo",
-                "-y",
-                "pipe:1",
-            ]
-
-            # Start FFmpeg process
+            total_duration = metadata.total_seconds
+
+            # Validate time bounds
+            if start_second is not None and start_second < 0:
+                raise ValueError("start_second must be non-negative")
+            if end_second is not None and end_second > total_duration:
+                raise ValueError(f"end_second ({end_second}) exceeds video duration ({total_duration})")
+            if start_second is not None and end_second is not None and start_second >= end_second:
+                raise ValueError("start_second must be less than end_second")
+
+            # Build FFmpeg command with improved segment handling
+            ffmpeg_cmd = ["ffmpeg"]
+
+            # Add seek option BEFORE input for more efficient seeking
+            if start_second is not None:
+                ffmpeg_cmd.extend(["-ss", str(start_second)])
+
+            ffmpeg_cmd.extend(["-i", path])
+
+            # Add duration AFTER input for more precise timing
+            if end_second is not None and start_second is not None:
+                duration = end_second - start_second
+                ffmpeg_cmd.extend(["-t", str(duration)])
+            elif end_second is not None:
+                ffmpeg_cmd.extend(["-t", str(end_second)])
+
+            # Output format settings - removed problematic -vsync 0
+            ffmpeg_cmd.extend(
+                [
+                    "-f",
+                    "rawvideo",
+                    "-pix_fmt",
+                    "rgb24",
+                    "-vcodec",
+                    "rawvideo",
+                    "-avoid_negative_ts",
+                    "make_zero",  # Handle timing issues
+                    "-y",
+                    "pipe:1",
+                ]
+            )
+
+            # Start FFmpeg process with stderr redirected to avoid deadlock
             process = subprocess.Popen(
                 ffmpeg_cmd,
                 stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                bufsize=10**8,  # Use large buffer
+                stderr=subprocess.DEVNULL,  # Redirect stderr to avoid deadlock
+                bufsize=10**8,  # Use large buffer for efficient I/O
             )
 
             # Calculate frame size in bytes
             frame_size = width * height * 3  # 3 bytes per pixel for RGB
 
-            # Pre-allocate numpy array for all frames
-            frames = np.empty((total_frames, height, width, 3), dtype=np.uint8)
-
-            # Read frames in batches
-            for frame_idx in range(0, total_frames, read_batch_size):
-                batch_end = min(frame_idx + read_batch_size, total_frames)
-                batch_size = batch_end - frame_idx
-
-                # Read batch of frames
-                raw_data = process.stdout.read(frame_size * batch_size)  # type: ignore
-                if not raw_data:
-                    break
-
-                # Convert raw bytes to numpy array and reshape
-                batch_frames = np.frombuffer(raw_data, dtype=np.uint8)
-                batch_frames = batch_frames.reshape(-1, height, width, 3)
-
-                # Store batch in pre-allocated array
-                frames[frame_idx:batch_end] = batch_frames
-
-            # Clean up FFmpeg process
-            process.stdout.close()  # type: ignore
-            process.stderr.close()  # type: ignore
-            process.wait()
+            # Estimate frame count for pre-allocation
+            if start_second is not None and end_second is not None:
+                estimated_duration = end_second - start_second
+            elif end_second is not None:
+                estimated_duration = end_second
+            elif start_second is not None:
+                estimated_duration = total_duration - start_second
+            else:
+                estimated_duration = total_duration
 
-            if process.returncode != 0:
-                raise ValueError(f"FFmpeg error: {process.stderr.read().decode()}")  # type: ignore
+            # Add 10% buffer to handle frame rate variations and rounding
+            estimated_frames = int(estimated_duration * fps * 1.1) + 10
 
-            new_vid.frames = frames
-            new_vid.fps = fps
+            # Pre-allocate numpy array
+            frames = np.empty((estimated_frames, height, width, 3), dtype=np.uint8)
+            frames_read = 0
 
-            # Load audio
             try:
-                new_vid.audio = Audio.from_file(path)
+                while frames_read < estimated_frames:
+                    # Calculate remaining frames to read
+                    remaining_frames = estimated_frames - frames_read
+                    batch_size = min(read_batch_size, remaining_frames)
+
+                    # Read batch of data
+                    batch_data = process.stdout.read(frame_size * batch_size)  # type: ignore
+
+                    if not batch_data:
+                        break
+
+                    # Convert to numpy array
+                    batch_frames = np.frombuffer(batch_data, dtype=np.uint8)
+
+                    # Calculate how many complete frames we got
+                    complete_frames = len(batch_frames) // (height * width * 3)
+
+                    if complete_frames == 0:
+                        break
+
+                    # Only keep complete frames
+                    complete_data = batch_frames[: complete_frames * height * width * 3]
+                    batch_frames_array = complete_data.reshape(complete_frames, height, width, 3)
+
+                    # Check if we have room in pre-allocated array
+                    if frames_read + complete_frames > estimated_frames:
+                        # Need to expand array - this should be rare with our buffer
+                        new_size = max(estimated_frames * 2, frames_read + complete_frames + 100)
+                        new_frames = np.empty((new_size, height, width, 3), dtype=np.uint8)
+                        new_frames[:frames_read] = frames[:frames_read]
+                        frames = new_frames
+                        estimated_frames = new_size
+
+                    # Store batch in pre-allocated array
+                    end_idx = frames_read + complete_frames
+                    frames[frames_read:end_idx] = batch_frames_array
+                    frames_read += complete_frames
+
+            finally:
+                # Ensure process is properly terminated
+                if process.poll() is None:
+                    process.terminate()
+                    try:
+                        process.wait(timeout=5)
+                    except subprocess.TimeoutExpired:
+                        process.kill()
+                        process.wait()
+
+                # Clean up pipes
+                if process.stdout:
+                    process.stdout.close()
+
+            # Check if FFmpeg had an error (non-zero return code)
+            if process.returncode not in (0, None) and frames_read == 0:
+                raise ValueError(f"FFmpeg failed to process video (return code: {process.returncode})")
+
+            if frames_read == 0:
+                raise ValueError("No frames were read from the video")
+
+            # Trim the pre-allocated array to actual frames read
+            frames = frames[:frames_read]  # type: ignore
+
+            # Load audio for the specified segment
+            try:
+                audio = Audio.from_file(path)
+                # Slice audio to match the video segment
+                if start_second is not None or end_second is not None:
+                    audio_start = start_second if start_second is not None else 0
+                    audio_end = end_second if end_second is not None else audio.metadata.duration_seconds
+                    audio = audio.slice(start_seconds=audio_start, end_seconds=audio_end)
             except Exception:
                 print(f"No audio found for `{path}`, adding silent track!")
-                new_vid.audio = Audio.create_silent(
-                    duration_seconds=round(new_vid.total_seconds, 2), stereo=True, sample_rate=44100
-                )
+                # Create silent audio based on actual frames read
+                segment_duration = frames_read / fps
+                audio = Audio.create_silent(duration_seconds=round(segment_duration, 2), stereo=True, sample_rate=44100)
 
-            return new_vid
+            return cls(frames=frames, fps=fps, audio=audio)
 
         except VideoMetadataError as e:
             raise ValueError(f"Error getting video metadata: {e}")
@@ -231,32 +313,23 @@ 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 = Audio.create_silent(
-            duration_seconds=round(new_vid.total_seconds, 2), stereo=True, sample_rate=44100
-        )
-        return new_vid
+        return cls(frames=frames, fps=fps)
 
     @classmethod
     def from_image(cls, image: np.ndarray, fps: float = 24.0, length_seconds: float = 1.0) -> Video:
-        new_vid = cls()
         if len(image.shape) == 3:
             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 = Audio.create_silent(duration_seconds=length_seconds, stereo=True, sample_rate=44100)
-        return new_vid
+        frames = np.repeat(image, round(length_seconds * fps), axis=0)
+        return cls(frames=frames, fps=fps)
 
     def copy(self) -> Video:
-        copied = Video().from_frames(self.frames.copy(), self.fps)
+        copied = Video.from_frames(self.frames.copy(), self.fps)
         copied.audio = self.audio  # Audio objects are immutable, no need to copy
         return copied
 
@@ -376,6 +449,20 @@ class Video:
                     raise
 
     def add_audio(self, audio: Audio, overlay: bool = True) -> None:
+        video_duration = self.total_seconds
+        audio_duration = audio.metadata.duration_seconds
+
+        if audio_duration > video_duration:
+            audio = audio.slice(start_seconds=0, end_seconds=video_duration)
+        elif audio_duration < video_duration:
+            silence_duration = video_duration - audio_duration
+            silence = Audio.create_silent(
+                duration_seconds=silence_duration,
+                stereo=audio.metadata.channels == 2,
+                sample_rate=audio.metadata.sample_rate,
+            )
+            audio = audio.concat(silence)
+
         if self.audio.is_silent:
             self.audio = audio
         elif overlay:

videopython-0.5.0.dist-info/METADATA

@@ -0,0 +1,194 @@
+Metadata-Version: 2.4
+Name: videopython
+Version: 0.5.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: ai,editing,generation,movie,opencv,python,shorts,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
+Classifier: Programming Language :: Python :: 3.12
+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: soundpython>=0.1.11
+Requires-Dist: tqdm>=4.66.3
+Provides-Extra: ai
+Requires-Dist: accelerate>=0.29.2; extra == 'ai'
+Requires-Dist: diffusers>=0.26.3; extra == 'ai'
+Requires-Dist: numba>=0.61.0; extra == 'ai'
+Requires-Dist: openai-whisper>=20240930; extra == 'ai'
+Requires-Dist: torch>=2.1.0; extra == 'ai'
+Requires-Dist: transformers>=4.38.1; extra == 'ai'
+Provides-Extra: dev
+Requires-Dist: mypy>=1.8.0; extra == 'dev'
+Requires-Dist: pytest-cov>=6.1.1; extra == 'dev'
+Requires-Dist: pytest>=7.4.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.14; extra == 'dev'
+Requires-Dist: types-pillow>=10.2.0.20240213; extra == 'dev'
+Requires-Dist: types-tqdm>=4.66.0.20240106; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# About
+
+Videopython is a minimal video generation and processing library designed with short-form videos in mind, with focus on simplicity and ease of use for both humans and AI agents.
+
+# Setup
+
+## Install ffmpeg
+```bash
+# Install with brew for MacOS:
+brew install ffmpeg
+# Install with apt-get for Ubuntu:
+sudo apt-get install ffmpeg
+```
+
+## Install library
+
+```bash
+# Install with your favourite package manager
+uv add videopython --extra ai
+
+# pip install works as well :)
+pip install videopython[ai]
+```
+
+> You can install without `[ai]` dependencies for basic video handling and processing.
+> The functionalities found in `videopython.ai` won't work.
+
+# Usage examples
+
+## Basic video editing
+
+```python
+from videopython.base.video import Video
+
+# Load videos and print metadata
+video1 = Video.from_path("tests/test_data/small_video.mp4")
+print(video1)
+
+video2 = Video.from_path("tests/test_data/big_video.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()
+```
+
+## AI powered examples
+
+### Video Generation
+
+> Using Nvidia A40 or better is recommended for the `videopython.ai` module.
+```python
+# Generate image and animate it
+from videopython.ai.generation import ImageToVideo
+from videopython.ai.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.ai.generation import TextToVideo
+video_gen = TextToVideo()
+video = video_gen.generate_video("Dogs playing in the park")
+for _ in range(10):
+    video += video_gen.generate_video("Dogs playing in the park")
+```
+
+### Audio generation
+```python
+from videopython.base.video import Video
+video = Video.from_path("<PATH_TO_VIDEO>")
+
+# Generate music on top of video
+from videopython.ai.generation import TextToMusic
+text_to_music = TextToMusic()
+audio = text_to_music.generate_audio("Happy dogs playing together in a park", max_new_tokens=256)
+video.add_audio(audio=audio)
+
+# Add TTS on top of video
+from videopython.ai.generation import TextToSpeech
+text_to_speech = TextToSpeech()
+audio = text_to_speech.generate_audio("Woof woof woof! Woooooof!")
+video.add_audio(audio=audio)
+```
+
+### Generate and overlay subtitles
+```python
+from videopython.base.video import Video
+video = Video.from_path("<PATH_TO_VIDEO>")
+
+# Generate transcription with timestamps
+from videopython.ai.understanding.transcribe import CreateTranscription
+transcription = CreateTranscription("base").transcribe(video)
+# Initialise object for overlaying. See `TranscriptionOverlay` to see detailed configuration options.
+from videopython.base.text.overlay import TranscriptionOverlay
+transcription_overlay = TranscriptionOverlay(font_filename="src/tests/test_data/test_font.ttf")
+
+video = transcription_overlay.apply(video, transcription)
+video.save()
+```
+
+# Development notes
+
+## Project structure
+
+Source code of the project can be found under `src/` directory, along with separate directories for unit tests and mypy stubs.
+```
+.
+└── src
+    ├── stubs # Contains stubs for mypy
+    ├── tests # Unit tests
+    └── videopython # Library code
+```
+
+----
+
+The `videopython` library is divided into 2 separate high-level modules:
+* `videopython.base`: Contains base classes for handling videos and for basic video editing. There are no imports from `videopython.ai` within the `base` module, which allows users to install light-weight base dependencies to do simple video operations.
+* `videopython.ai`: Contains AI-powered functionalities for video generation. It has its own `ai` dependency group, which contains all dependencies required to run AI models.
+
+## Running locally
+
+We are using [uv](https://docs.astral.sh/uv/) as project and package manager. Once you clone the repo and install uv locally, you can use it to sync the dependencies.
+```bash
+uv sync --all-extras
+```
+
+To run the unit tests, you can simply run:
+```bash
+uv run pytest
+```
+
+We also use [Ruff](https://docs.astral.sh/ruff/) for linting/formatting and [mypy](https://github.com/python/mypy) as type checker.
+```bash
+# Run formatting
+uv run ruff format
+# Run linting and apply fixes
+uv run ruff check --fix
+# Run type checks
+uv run mypy src/
+```

{videopython-0.4.0.dist-info → videopython-0.5.0.dist-info}/RECORD

@@ -6,20 +6,19 @@ videopython/ai/generation/audio.py,sha256=CNf6ZeV3iU4CU0Kq8HtDLwLPP2ABq9AGQD1TBO
 videopython/ai/generation/image.py,sha256=gS0zqzyIoCvjTjfks31ApG8lX0nUKXWRRgFGGLN4RjM,654
 videopython/ai/generation/video.py,sha256=206YON_XjPTYyjIJ3j5uBgd_yHmCDg7SqbkIU9GzEgw,1831
 videopython/ai/understanding/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-videopython/ai/understanding/transcribe.py,sha256=VNgXnzbTH0NHDKHjanj6CjUnl-XwT-nsOkd5zqn9a_E,1219
+videopython/ai/understanding/transcribe.py,sha256=hm2f5Fm1O_tMrSmUlcUdl_rQRhc5Sz_kaV4tnJ4IxbQ,2557
 videopython/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-videopython/base/compose.py,sha256=pti12VY3Yg7TZZiENPF6veM8POWssfsK8ePDdGlhAhA,1968
+videopython/base/combine.py,sha256=XC_pzyhbIh6h0fmxX1LhhhtlmOBbUQX9Y4EtDJqQn8g,1900
 videopython/base/effects.py,sha256=1RbRLTQD0V26DBc4jbRCDI4eGr6-TyBdX-Ia2USKxmc,7554
 videopython/base/exceptions.py,sha256=68_16lUPOR9_zhWdeBGS8_NFI32VbrcoDbN5KHHg0_w,44
-videopython/base/transcription.py,sha256=FloqvY-OlBQPOCkPnSx6R7azn4smD5-JYd-pMNssuYw,196
 videopython/base/transforms.py,sha256=FDh-8EgQoZxB6Gv-T15kZGctcu9_4XHsTy_n7kgxlQw,5828
 videopython/base/transitions.py,sha256=P1bBsxugf5i0JEtx7MoRgxWSIDcBli-0QucRwBIFGqs,3687
-videopython/base/video.py,sha256=uhNGa9BBUEitEfk1Fn8IhtI-we2-Qy-iDV6Lj0OBeq4,15712
-videopython/utils/__init__.py,sha256=uhFG_cnw6zZUWxpfs_I3-82mh-NBLqivbPDnsdOEUmI,122
-videopython/utils/common.py,sha256=F-30YoKUwWDI7HiJUWw0gRFUguhShSVaxT0aFfvpifg,936
-videopython/utils/image.py,sha256=zR5_WnSBXGgyE9gNpXnNXmPtfdmnlY7kdOsgkZUGOds,1747
-videopython/utils/text.py,sha256=T0W6VgpLfLczMMdUXEhkEftUQmuNzuQusO9I7-HU8Zg,27962
-videopython-0.4.0.dist-info/METADATA,sha256=MY4BiT2PTFoZeJFxQLsa9KxaFKGdsBhJfMveq2f1bhg,3852
-videopython-0.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-videopython-0.4.0.dist-info/licenses/LICENSE,sha256=nJL9jVOt2MSW7swNDq4Y6oD_n9bLI0B0afr8ougtZ6s,10832
-videopython-0.4.0.dist-info/RECORD,,
+videopython/base/utils.py,sha256=bAwIagHvd1NWu8UYAsS-pDm38E4R8qRfeHvWk-O2__0,125
+videopython/base/video.py,sha256=RxKHmR39EEvBa5m2xFDNj4_mq213RUG3NQ_lhk5U-PA,20462
+videopython/base/text/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+videopython/base/text/overlay.py,sha256=EiBDSsnn2pSGeWGajblUxovcP_IdA6gk2zZ5rsjhdI8,44434
+videopython/base/text/transcription.py,sha256=9c3FRBr7RkialHhdfSwEX303QnIt1sCSiXoId9_DRkk,4246
+videopython-0.5.0.dist-info/METADATA,sha256=FTo8Bo3YLhp9bGTrctiehMMksQwecH1DN84JO5RydyU,6574
+videopython-0.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+videopython-0.5.0.dist-info/licenses/LICENSE,sha256=nJL9jVOt2MSW7swNDq4Y6oD_n9bLI0B0afr8ougtZ6s,10832
+videopython-0.5.0.dist-info/RECORD,,