Following this instruction :
1. Strictly adhere to PEP-8 standards, ensuring code is clean, well-structured, and follows Python's style guide for readability.
2. Use appropriate modules like `typing` for type hints, ensuring code clarity, maintainability, and leveraging Python's standard libraries effectively.
3. Focus on time, space, robustness, scalability; write optimized, efficient code that can handle large datasets and scale seamlessly.
4. Implement comprehensive error handling, catching exceptions gracefully, providing meaningful error messages, and ensuring code robustness under unexpected conditions.
5. Ensure the developer agent writes advanced, maintainable Python code, balancing performance and readability while adhering to best practices.


TASK: Problem Statement: Reusable, Generalized, and Robust Video Editing Module in Python
With the increasing demand for video content creation across various platforms, from social media to professional applications, there is a growing need for flexible and efficient video editing tools. However, most existing video editing solutions are either too rigid for developers to customize or too resource-intensive for simple, task-oriented use cases. This creates a significant challenge for developers and content creators who require a reusable, generalized, and robust video editing solution, especially when integrating multiple media elements like video, text, and audio.

The problem lies in the lack of a Python-based, modular editing tool that can handle these requirements efficiently. Current video editing frameworks are often limited by their specialized nature, with pre-defined workflows that are difficult to customize for new projects. Many existing tools either fail to manage large video files effectively, provide inadequate support for text and audio overlays, or lack the modular design needed to adapt to various input formats and user-defined transformations. The challenge is to create a system that integrates all these capabilities in a way that is both flexible and lightweight.

We propose to develop a Python module that addresses these gaps by offering a highly customizable, reusable, and robust solution for video editing. The module will support three core functionalities:

Text Overlay: This includes the ability to add customizable text on videos with options for font size, color, position, and duration, enabling creators to seamlessly integrate text into their videos.
Audio Replacement or Mixing: Users can replace or mix the original audio with a new track, ensuring synchronization and compatibility between the video and audio.
Video Manipulation: The module will provide basic video transformation tools such as trimming, rotating, merging, and speeding up or slowing down specific sections.
By leveraging Python libraries like moviepy, opencv, and pydub, the module will ensure efficient performance, error handling, and scalability, making it a comprehensive solution for modern video editing needs.


Sample or reference code :

from typing import Optional, Tuple, List, Union
from moviepy.editor import (
    VideoFileClip,
    AudioFileClip,
    CompositeVideoClip,
    CompositeAudioClip,
    TextClip,
    concatenate_videoclips,
    vfx,
)
import os


class VideoEditor:
    """
    A reusable, generalized, and robust video editing module that supports text overlay,
    audio replacement or mixing, and basic video manipulation functionalities.
    """

    def __init__(self, video_path: str) -> None:
        """
        Initialize the VideoEditor with a video file.

        :param video_path: Path to the input video file.
        """
        if not os.path.isfile(video_path):
            raise FileNotFoundError(f"The video file '{video_path}' does not exist.")
        try:
            self.video_clip: VideoFileClip = VideoFileClip(video_path)
        except Exception as e:
            raise Exception(f"Failed to load video file '{video_path}': {e}")

    def add_text_overlay(
        self,
        text: str,
        position: Tuple[Union[int, str], Union[int, str]] = ("center", "bottom"),
        fontsize: int = 24,
        color: str = "white",
        start_time: float = 0.0,
        duration: Optional[float] = None,
    ) -> None:
        """
        Add text overlay to the video.

        :param text: Text to display.
        :param position: Position of the text on the video.
        :param fontsize: Font size of the text.
        :param color: Color of the text.
        :param start_time: Start time in seconds for the text to appear.
        :param duration: Duration in seconds for which the text will appear.
        """
        try:
            txt_clip = TextClip(
                text,
                fontsize=fontsize,
                color=color,
                size=self.video_clip.size,
                method="caption",
            )
            txt_clip = txt_clip.set_position(position).set_start(start_time)
            if duration is not None:
                txt_clip = txt_clip.set_duration(duration)
            else:
                txt_clip = txt_clip.set_duration(self.video_clip.duration - start_time)
            self.video_clip = CompositeVideoClip([self.video_clip, txt_clip])
        except Exception as e:
            raise Exception(f"Failed to add text overlay: {e}")

    def replace_audio(self, audio_path: str) -> None:
        """
        Replace the video's audio with a new audio track.

        :param audio_path: Path to the new audio file.
        """
        if not os.path.isfile(audio_path):
            raise FileNotFoundError(f"The audio file '{audio_path}' does not exist.")
        try:
            new_audio = AudioFileClip(audio_path)
            self.video_clip = self.video_clip.set_audio(new_audio)
        except Exception as e:
            raise Exception(f"Failed to replace audio: {e}")

    def mix_audio(self, audio_path: str) -> None:
        """
        Mix the video's audio with a new audio track.

        :param audio_path: Path to the new audio file.
        """
        if not os.path.isfile(audio_path):
            raise FileNotFoundError(f"The audio file '{audio_path}' does not exist.")
        try:
            original_audio = self.video_clip.audio
            new_audio = AudioFileClip(audio_path)
            mixed_audio = CompositeAudioClip([original_audio, new_audio])
            self.video_clip = self.video_clip.set_audio(mixed_audio)
        except Exception as e:
            raise Exception(f"Failed to mix audio: {e}")

    def trim(self, start_time: float, end_time: float) -> None:
        """
        Trim the video between the start_time and end_time.

        :param start_time: Start time in seconds.
        :param end_time: End time in seconds.
        """
        try:
            self.video_clip = self.video_clip.subclip(start_time, end_time)
        except Exception as e:
            raise Exception(f"Failed to trim video: {e}")

    def rotate(self, angle: float) -> None:
        """
        Rotate the video by a specified angle.

        :param angle: Angle in degrees to rotate the video.
        """
        try:
            self.video_clip = self.video_clip.rotate(angle)
        except Exception as e:
            raise Exception(f"Failed to rotate video: {e}")

    def merge_videos(self, video_paths: List[str]) -> None:
        """
        Merge the current video with other videos.

        :param video_paths: List of paths to video files to be merged.
        """
        clips = [self.video_clip]
        try:
            for path in video_paths:
                if not os.path.isfile(path):
                    raise FileNotFoundError(f"The video file '{path}' does not exist.")
                clip = VideoFileClip(path)
                clips.append(clip)
            self.video_clip = concatenate_videoclips(clips)
        except Exception as e:
            raise Exception(f"Failed to merge videos: {e}")

    def change_speed(self, factor: float) -> None:
        """
        Speed up or slow down the video.

        :param factor: Factor by which to change the speed (>1 speeds up, <1 slows down).
        """
        try:
            self.video_clip = self.video_clip.fx(vfx.speedx, factor)
        except Exception as e:
            raise Exception(f"Failed to change video speed: {e}")

    def save(self, output_path: str, codec: str = "libx264") -> None:
        """
        Save the edited video to a file.

        :param output_path: Path to save the output video file.
        :param codec: Codec to use for encoding the video.
        """
        try:
            self.video_clip.write_videofile(output_path, codec=codec)
        except Exception as e:
            raise Exception(f"Failed to save video to '{output_path}': {e}")

    def close(self) -> None:
        """
        Close the video clip and free resources.
        """
        try:
            self.video_clip.close()
        except Exception as e:
            raise Exception(f"Failed to close video clip: {e}")