videopython 0.26.2__tar.gz → 0.26.4__tar.gz

{videopython-0.26.2 → videopython-0.26.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: videopython
-Version: 0.26.2
+Version: 0.26.4
 Summary: Minimal video generation and processing library.
 Project-URL: Homepage, https://videopython.com
 Project-URL: Repository, https://github.com/bartwojtowicz/videopython/

{videopython-0.26.2 → videopython-0.26.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "videopython"
-version = "0.26.2"
+version = "0.26.4"
 description = "Minimal video generation and processing library."
 authors = [
     { name = "Bartosz Wójtowicz", email = "bartoszwojtowicz@outlook.com" },

{videopython-0.26.2 → videopython-0.26.4}/src/videopython/ai/dubbing/dubber.py

@@ -3,6 +3,8 @@
 from __future__ import annotations
 
 import logging
+import tempfile
+from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable
 
 from videopython.ai.dubbing.models import DubbingResult, RevoiceResult
@@ -60,7 +62,7 @@ class VideoDubber:
             self._init_local_pipeline()
 
         return self._local_pipeline.process(
-            video=video,
+            source_audio=video.audio,
             target_lang=target_lang,
             source_lang=source_lang,
             preserve_background=preserve_background,
@@ -99,6 +101,84 @@ class VideoDubber:
         )
         return video.add_audio(result.dubbed_audio, overlay=False)
 
+    def dub_file(
+        self,
+        input_path: str | Path,
+        output_path: str | Path,
+        target_lang: str,
+        source_lang: str | None = None,
+        preserve_background: bool = True,
+        voice_clone: bool = True,
+        enable_diarization: bool = False,
+        progress_callback: Callable[[str, float], None] | None = None,
+        transcription: Any = None,
+    ) -> DubbingResult:
+        """Dub a video file in place on disk without loading video frames into memory.
+
+        Extracts the audio track via ffmpeg, runs the dubbing pipeline on the
+        audio only, then muxes the dubbed audio back into the source video
+        using ffmpeg stream-copy (no video re-encode). Peak memory is bounded
+        by model weights and the audio track — independent of video length and
+        resolution.
+
+        Use this instead of ``dub_and_replace`` when the source video is long
+        or high-resolution and you don't need frame-level access in Python.
+
+        Args:
+            input_path: Path to the source video file.
+            output_path: Path to write the dubbed video. Overwritten if it exists.
+            target_lang: Target language code (e.g. ``"es"``, ``"fr"``).
+            source_lang: Source language code, or ``None`` to auto-detect.
+            preserve_background: Preserve background music/effects via source separation.
+            voice_clone: Clone the source speaker's voice for the dubbed track.
+            enable_diarization: Enable speaker diarization for per-speaker voice cloning.
+            progress_callback: Optional callback ``(stage: str, progress: float) -> None``.
+            transcription: Optional pre-computed ``Transcription`` to skip the Whisper step.
+
+        Returns:
+            ``DubbingResult`` with the dubbed audio, translated segments, and
+            source transcription. The output video is written to ``output_path``.
+        """
+        from videopython.ai.dubbing.remux import replace_audio_stream
+        from videopython.base.audio import Audio
+
+        input_path = Path(input_path)
+        output_path = Path(output_path)
+
+        if not input_path.exists():
+            raise FileNotFoundError(f"Input video not found: {input_path}")
+
+        logger.info("dub_file: loading audio from %s", input_path)
+        source_audio = Audio.from_path(input_path)
+
+        if self._local_pipeline is None:
+            self._init_local_pipeline()
+
+        result = self._local_pipeline.process(
+            source_audio=source_audio,
+            target_lang=target_lang,
+            source_lang=source_lang,
+            preserve_background=preserve_background,
+            voice_clone=voice_clone,
+            enable_diarization=enable_diarization,
+            progress_callback=progress_callback,
+            transcription=transcription,
+        )
+
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp:
+            dubbed_audio_path = Path(tmp.name)
+        try:
+            result.dubbed_audio.save(dubbed_audio_path)
+            replace_audio_stream(
+                video_path=input_path,
+                audio_path=dubbed_audio_path,
+                output_path=output_path,
+            )
+        finally:
+            dubbed_audio_path.unlink(missing_ok=True)
+
+        return result
+
     def revoice(
         self,
         video: Video,
@@ -111,7 +191,7 @@ class VideoDubber:
             self._init_local_pipeline()
 
         return self._local_pipeline.revoice(
-            video=video,
+            source_audio=video.audio,
             text=text,
             preserve_background=preserve_background,
             progress_callback=progress_callback,

{videopython-0.26.2 → videopython-0.26.4}/src/videopython/ai/dubbing/pipeline.py

@@ -9,7 +9,7 @@ from videopython.ai.dubbing.models import DubbingResult, RevoiceResult, Separate
 from videopython.ai.dubbing.timing import TimingSynchronizer
 
 if TYPE_CHECKING:
-    from videopython.base.video import Video
+    from videopython.base.audio import Audio
 
 logger = logging.getLogger(__name__)
 
@@ -37,7 +37,6 @@ class LocalDubbingPipeline:
         self._transcriber_diarization: bool | None = None
         self._translator: Any = None
         self._tts: Any = None
-        self._tts_voice_clone: bool | None = None
         self._tts_language: str | None = None
         self._separator: Any = None
         self._synchronizer: TimingSynchronizer | None = None
@@ -71,18 +70,11 @@ class LocalDubbingPipeline:
 
         self._translator = TextTranslator(device=self.device)
 
-    def _init_tts(self, voice_clone: bool = False, language: str = "en") -> None:
+    def _init_tts(self, language: str = "en") -> None:
         """Initialize the text-to-speech model."""
         from videopython.ai.generation.audio import TextToSpeech
 
-        if voice_clone:
-            self._tts = TextToSpeech(
-                model_size="chatterbox",
-                device=self.device,
-                language=language,
-            )
-        else:
-            self._tts = TextToSpeech(device=self.device, language=language)
+        self._tts = TextToSpeech(device=self.device, language=language)
 
     def _init_separator(self) -> None:
         """Initialize the audio separator."""
@@ -102,7 +94,6 @@ class LocalDubbingPipeline:
         max_duration: float = 10.0,
     ) -> dict[str, Any]:
         """Extract voice samples for each speaker from the audio."""
-        from videopython.base.audio import Audio
 
         voice_samples: dict[str, Audio] = {}
 
@@ -135,7 +126,7 @@ class LocalDubbingPipeline:
 
     def process(
         self,
-        video: Video,
+        source_audio: Audio,
         target_lang: str,
         source_lang: str | None = None,
         preserve_background: bool = True,
@@ -144,22 +135,22 @@ class LocalDubbingPipeline:
         progress_callback: Callable[[str, float], None] | None = None,
         transcription: Any | None = None,
     ) -> DubbingResult:
-        """Process a video through the local dubbing pipeline.
+        """Run the dubbing pipeline against the given source audio.
 
         Args:
+            source_audio: Source audio track to dub. Callers with a ``Video``
+                object should pass ``video.audio``; callers with only a file path
+                can use ``Audio.from_path(path)`` to avoid loading video frames.
             transcription: Optional pre-computed Transcription object. When provided,
                 the internal Whisper transcription step is skipped (saving time and VRAM).
                 Must be a ``videopython.base.text.transcription.Transcription`` instance
                 with populated ``segments``.
         """
-        from videopython.base.audio import Audio
 
         def report_progress(stage: str, progress: float) -> None:
             if progress_callback:
                 progress_callback(stage, progress)
 
-        source_audio = video.audio
-
         if transcription is not None:
             report_progress("Using provided transcription", 0.05)
         else:
@@ -211,9 +202,8 @@ class LocalDubbingPipeline:
         self._maybe_unload("_translator")
 
         report_progress("Generating dubbed speech", 0.50)
-        if self._tts is None or self._tts_voice_clone != voice_clone or self._tts_language != target_lang:
-            self._init_tts(voice_clone=voice_clone, language=target_lang)
-            self._tts_voice_clone = voice_clone
+        if self._tts is None or self._tts_language != target_lang:
+            self._init_tts(language=target_lang)
             self._tts_language = target_lang
 
         dubbed_segments: list[Audio] = []
@@ -275,19 +265,23 @@ class LocalDubbingPipeline:
 
     def revoice(
         self,
-        video: Video,
+        source_audio: Audio,
         text: str,
         preserve_background: bool = True,
         progress_callback: Callable[[str, float], None] | None = None,
     ) -> RevoiceResult:
-        """Replace speech in a video with new text using voice cloning."""
+        """Replace speech in audio with new text using voice cloning.
+
+        Args:
+            source_audio: Source audio track to revoice. Callers with a ``Video``
+                object should pass ``video.audio``.
+        """
         from videopython.base.audio import Audio
 
         def report_progress(stage: str, progress: float) -> None:
             if progress_callback:
                 progress_callback(stage, progress)
 
-        source_audio = video.audio
         original_duration = source_audio.metadata.duration_seconds
 
         report_progress("Analyzing audio", 0.05)
@@ -323,9 +317,8 @@ class LocalDubbingPipeline:
             voice_sample = vocal_audio.slice(0, sample_duration)
 
         report_progress("Generating speech", 0.60)
-        if self._tts is None or self._tts_voice_clone is not True or self._tts_language != "en":
-            self._init_tts(voice_clone=True, language="en")
-            self._tts_voice_clone = True
+        if self._tts is None or self._tts_language != "en":
+            self._init_tts(language="en")
             self._tts_language = "en"
 
         generated_speech = self._tts.generate_audio(text, voice_sample=voice_sample)

videopython-0.26.4/src/videopython/ai/dubbing/remux.py

@@ -0,0 +1,73 @@
+"""ffmpeg helper for replacing a video file's audio track without re-encoding video."""
+
+from __future__ import annotations
+
+import logging
+import subprocess
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+class RemuxError(RuntimeError):
+    """ffmpeg failed while replacing an audio stream."""
+
+
+def replace_audio_stream(
+    video_path: str | Path,
+    audio_path: str | Path,
+    output_path: str | Path,
+    audio_codec: str = "aac",
+    audio_bitrate: str = "192k",
+) -> None:
+    """Copy ``video_path``'s video stream and mux in ``audio_path`` as the audio track.
+
+    Uses ffmpeg stream-copy for video (no re-encode) and encodes audio to AAC.
+    ``-shortest`` trims to the shorter of the two streams so the output duration
+    matches the source video when the dubbed audio is slightly longer.
+
+    Args:
+        video_path: Source video file (video stream is copied unchanged).
+        audio_path: Audio file to use as the new audio track.
+        output_path: Destination file. Overwritten if it exists.
+        audio_codec: ffmpeg audio codec name. Defaults to ``aac`` (MP4-compatible).
+        audio_bitrate: Audio bitrate passed to ffmpeg (``-b:a``).
+
+    Raises:
+        FileNotFoundError: If ``video_path`` or ``audio_path`` does not exist.
+        RemuxError: If ffmpeg returns a non-zero exit code.
+    """
+    video_path = Path(video_path)
+    audio_path = Path(audio_path)
+    output_path = Path(output_path)
+
+    if not video_path.exists():
+        raise FileNotFoundError(f"Video file not found: {video_path}")
+    if not audio_path.exists():
+        raise FileNotFoundError(f"Audio file not found: {audio_path}")
+
+    cmd = [
+        "ffmpeg",
+        "-y",
+        "-i",
+        str(video_path),
+        "-i",
+        str(audio_path),
+        "-map",
+        "0:v:0",
+        "-map",
+        "1:a:0",
+        "-c:v",
+        "copy",
+        "-c:a",
+        audio_codec,
+        "-b:a",
+        audio_bitrate,
+        "-shortest",
+        str(output_path),
+    ]
+
+    logger.info("replace_audio_stream: %s + %s -> %s", video_path, audio_path, output_path)
+    result = subprocess.run(cmd, capture_output=True)
+    if result.returncode != 0:
+        raise RemuxError(f"ffmpeg failed (exit {result.returncode}): {result.stderr.decode(errors='replace')}")

videopython-0.26.4/src/videopython/ai/generation/audio.py

@@ -0,0 +1,156 @@
+"""Audio generation using local models."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from videopython.ai._device import log_device_initialization, release_device_memory, select_device
+from videopython.base.audio import Audio, AudioMetadata
+
+
+class TextToSpeech:
+    """Generates speech audio from text using Chatterbox Multilingual.
+
+    Backed by Chatterbox Multilingual (Resemble AI). When ``voice_sample`` is
+    provided to ``generate_audio``, the model clones that voice; otherwise it
+    falls back to Chatterbox's built-in default speaker.
+    """
+
+    SAMPLE_RATE: int = 24000
+
+    def __init__(
+        self,
+        voice: Audio | None = None,
+        device: str | None = None,
+        language: str = "en",
+    ):
+        self.voice = voice
+        self.device = device
+        self.language = language
+        self._model: Any = None
+
+    def _init_model(self) -> None:
+        from chatterbox.mtl_tts import ChatterboxMultilingualTTS  # type: ignore[import-untyped]
+
+        requested_device = self.device
+        device = select_device(self.device, mps_allowed=False)
+
+        self._model = ChatterboxMultilingualTTS.from_pretrained(device=device)
+        self.device = device
+        log_device_initialization(
+            "TextToSpeech",
+            requested_device=requested_device,
+            resolved_device=device,
+        )
+
+    def generate_audio(
+        self,
+        text: str,
+        voice_sample: Audio | None = None,
+    ) -> Audio:
+        """Generate speech audio from text.
+
+        Args:
+            text: Text to synthesize.
+            voice_sample: Optional voice sample to clone. Falls back to the
+                instance's ``voice`` and then to Chatterbox's default speaker.
+        """
+        import tempfile
+        from pathlib import Path
+
+        import numpy as np
+
+        if self._model is None:
+            self._init_model()
+
+        effective_sample = voice_sample or self.voice
+        speaker_wav_path: Path | None = None
+
+        if effective_sample is not None:
+            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
+                effective_sample.save(f.name)
+                speaker_wav_path = Path(f.name)
+
+        try:
+            wav = self._model.generate(
+                text=text,
+                language_id=self.language,
+                audio_prompt_path=str(speaker_wav_path) if speaker_wav_path else None,
+            )
+
+            audio_data = wav.cpu().float().numpy().squeeze()
+            if audio_data.ndim == 0:
+                audio_data = np.array([audio_data], dtype=np.float32)
+
+            metadata = AudioMetadata(
+                sample_rate=self.SAMPLE_RATE,
+                channels=1,
+                sample_width=2,
+                duration_seconds=len(audio_data) / self.SAMPLE_RATE,
+                frame_count=len(audio_data),
+            )
+            return Audio(audio_data, metadata)
+        finally:
+            if speaker_wav_path is not None:
+                speaker_wav_path.unlink()
+
+    def unload(self) -> None:
+        """Release the TTS model so the next generate_audio() re-initializes.
+
+        Used by low-memory dubbing to free VRAM between pipeline stages.
+        """
+        self._model = None
+        release_device_memory(self.device)
+
+
+class TextToMusic:
+    """Generates music from text descriptions using MusicGen."""
+
+    def __init__(self, device: str | None = None):
+        self.device = device
+        self._processor: Any = None
+        self._model: Any = None
+        self._device: str | None = None
+
+    def _init_local(self) -> None:
+        """Initialize local MusicGen model."""
+        import os
+
+        from transformers import AutoProcessor, MusicgenForConditionalGeneration
+
+        os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1"
+
+        requested_device = self.device
+        self._device = select_device(self.device, mps_allowed=True)
+
+        model_name = "facebook/musicgen-small"
+        self._processor = AutoProcessor.from_pretrained(model_name)
+        self._model = MusicgenForConditionalGeneration.from_pretrained(model_name)
+        self._model.to(self._device)
+        self.device = self._device
+        log_device_initialization(
+            "TextToMusic",
+            requested_device=requested_device,
+            resolved_device=self._device,
+        )
+
+    def generate_audio(self, text: str, max_new_tokens: int = 256) -> Audio:
+        """Generate music audio from text description."""
+        if self._model is None:
+            self._init_local()
+
+        inputs = self._processor(text=[text], padding=True, return_tensors="pt")
+        inputs = {k: v.to(self._device) if hasattr(v, "to") else v for k, v in inputs.items()}
+        audio_values = self._model.generate(**inputs, max_new_tokens=max_new_tokens)
+        sampling_rate = self._model.config.audio_encoder.sampling_rate
+
+        audio_data = audio_values[0, 0].cpu().float().numpy()
+
+        metadata = AudioMetadata(
+            sample_rate=sampling_rate,
+            channels=1,
+            sample_width=2,
+            duration_seconds=len(audio_data) / sampling_rate,
+            frame_count=len(audio_data),
+        )
+        return Audio(audio_data, metadata)

videopython-0.26.2/src/videopython/ai/generation/audio.py

@@ -1,215 +0,0 @@
-"""Audio generation using local models."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from videopython.ai._device import log_device_initialization, release_device_memory, select_device
-from videopython.base.audio import Audio, AudioMetadata
-
-
-class TextToSpeech:
-    """Generates speech audio from text using local models.
-
-    Supports Bark (`base`, `small`) for general TTS and Chatterbox Multilingual
-    (`chatterbox`) for multilingual voice cloning.
-    """
-
-    SUPPORTED_LOCAL_MODELS: list[str] = ["base", "small", "chatterbox"]
-
-    CHATTERBOX_SAMPLE_RATE: int = 24000
-
-    def __init__(
-        self,
-        model_size: str = "base",
-        voice: str | None = None,
-        device: str | None = None,
-        language: str = "en",
-    ):
-        if model_size not in self.SUPPORTED_LOCAL_MODELS:
-            raise ValueError(f"model_size must be one of {self.SUPPORTED_LOCAL_MODELS}, got '{model_size}'")
-
-        self.model_size = model_size
-        self.voice = voice
-        self.device = device
-        self.language = language
-        self._model: Any = None
-        self._processor: Any = None
-        self._chatterbox_model: Any = None
-
-    def _init_local(self) -> None:
-        """Initialize local Bark model."""
-        from transformers import AutoModel, AutoProcessor
-
-        requested_device = self.device
-        device = select_device(self.device, mps_allowed=False)
-
-        model_name = "suno/bark" if self.model_size == "base" else "suno/bark-small"
-        self._processor = AutoProcessor.from_pretrained(model_name)
-        self._model = AutoModel.from_pretrained(model_name).to(device)
-        self.device = device
-        log_device_initialization(
-            "TextToSpeech",
-            requested_device=requested_device,
-            resolved_device=device,
-        )
-
-    def _init_chatterbox(self) -> None:
-        """Initialize Chatterbox Multilingual model for voice cloning."""
-        from chatterbox.mtl_tts import ChatterboxMultilingualTTS  # type: ignore[import-untyped]
-
-        requested_device = self.device
-        device = select_device(self.device, mps_allowed=False)
-
-        self._chatterbox_model = ChatterboxMultilingualTTS.from_pretrained(device=device)
-        self.device = device
-        log_device_initialization(
-            "TextToSpeech",
-            requested_device=requested_device,
-            resolved_device=device,
-        )
-
-    def _generate_local(self, text: str, voice_preset: str | None) -> Audio:
-        """Generate speech using Bark."""
-        import torch
-
-        if self._model is None:
-            self._init_local()
-
-        inputs = self._processor(text=[text], return_tensors="pt", voice_preset=voice_preset)
-        inputs = {k: v.to(self.device) if isinstance(v, torch.Tensor) else v for k, v in inputs.items()}
-
-        with torch.no_grad():
-            speech_values = self._model.generate(**inputs, do_sample=True)
-
-        audio_data = speech_values.cpu().float().numpy().squeeze()
-        sample_rate = self._model.generation_config.sample_rate
-
-        metadata = AudioMetadata(
-            sample_rate=sample_rate,
-            channels=1,
-            sample_width=2,
-            duration_seconds=len(audio_data) / sample_rate,
-            frame_count=len(audio_data),
-        )
-        return Audio(audio_data, metadata)
-
-    def _generate_chatterbox(self, text: str, voice_sample: Audio) -> Audio:
-        """Generate speech using Chatterbox Multilingual with voice cloning."""
-        import tempfile
-        from pathlib import Path
-
-        import numpy as np
-
-        if self._chatterbox_model is None:
-            self._init_chatterbox()
-
-        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
-            voice_sample.save(f.name)
-            speaker_wav_path = Path(f.name)
-
-        try:
-            wav = self._chatterbox_model.generate(
-                text=text,
-                language_id=self.language,
-                audio_prompt_path=str(speaker_wav_path),
-            )
-
-            audio_data = wav.cpu().float().numpy().squeeze()
-            if audio_data.ndim == 0:
-                audio_data = np.array([audio_data], dtype=np.float32)
-
-            sample_rate = self.CHATTERBOX_SAMPLE_RATE
-
-            metadata = AudioMetadata(
-                sample_rate=sample_rate,
-                channels=1,
-                sample_width=2,
-                duration_seconds=len(audio_data) / sample_rate,
-                frame_count=len(audio_data),
-            )
-            return Audio(audio_data, metadata)
-        finally:
-            speaker_wav_path.unlink()
-
-    def generate_audio(
-        self,
-        text: str,
-        voice_preset: str | None = None,
-        voice_sample: Audio | None = None,
-    ) -> Audio:
-        """Generate speech audio from text."""
-        effective_voice = voice_preset or self.voice
-
-        if self.model_size == "chatterbox" or voice_sample is not None:
-            if voice_sample is None:
-                raise ValueError(
-                    "voice_sample is required for Chatterbox voice cloning. "
-                    "Provide an Audio sample of the voice to clone."
-                )
-            return self._generate_chatterbox(text, voice_sample)
-
-        return self._generate_local(text, effective_voice)
-
-    def unload(self) -> None:
-        """Release the TTS model(s) so the next generate_audio() re-initializes.
-
-        Used by low-memory dubbing to free VRAM between pipeline stages.
-        """
-        self._model = None
-        self._processor = None
-        self._chatterbox_model = None
-        release_device_memory(self.device)
-
-
-class TextToMusic:
-    """Generates music from text descriptions using MusicGen."""
-
-    def __init__(self, device: str | None = None):
-        self.device = device
-        self._processor: Any = None
-        self._model: Any = None
-        self._device: str | None = None
-
-    def _init_local(self) -> None:
-        """Initialize local MusicGen model."""
-        import os
-
-        from transformers import AutoProcessor, MusicgenForConditionalGeneration
-
-        os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1"
-
-        requested_device = self.device
-        self._device = select_device(self.device, mps_allowed=True)
-
-        model_name = "facebook/musicgen-small"
-        self._processor = AutoProcessor.from_pretrained(model_name)
-        self._model = MusicgenForConditionalGeneration.from_pretrained(model_name)
-        self._model.to(self._device)
-        self.device = self._device
-        log_device_initialization(
-            "TextToMusic",
-            requested_device=requested_device,
-            resolved_device=self._device,
-        )
-
-    def generate_audio(self, text: str, max_new_tokens: int = 256) -> Audio:
-        """Generate music audio from text description."""
-        if self._model is None:
-            self._init_local()
-
-        inputs = self._processor(text=[text], padding=True, return_tensors="pt")
-        inputs = {k: v.to(self._device) if hasattr(v, "to") else v for k, v in inputs.items()}
-        audio_values = self._model.generate(**inputs, max_new_tokens=max_new_tokens)
-        sampling_rate = self._model.config.audio_encoder.sampling_rate
-
-        audio_data = audio_values[0, 0].cpu().float().numpy()
-
-        metadata = AudioMetadata(
-            sample_rate=sampling_rate,
-            channels=1,
-            sample_width=2,
-            duration_seconds=len(audio_data) / sampling_rate,
-            frame_count=len(audio_data),
-        )
-        return Audio(audio_data, metadata)