videopython 0.33.0__tar.gz → 0.33.1__tar.gz

{videopython-0.33.0 → videopython-0.33.1}/PKG-INFO

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

{videopython-0.33.0 → videopython-0.33.1}/pyproject.toml

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

{videopython-0.33.0 → videopython-0.33.1}/src/videopython/ai/generation/audio.py

@@ -32,7 +32,7 @@ class TextToSpeech:
         self.language = language
         self._model: Any = None
 
-    def _init_model(self) -> None:
+    def _init_local(self) -> None:
         from chatterbox.mtl_tts import ChatterboxMultilingualTTS  # type: ignore[import-untyped]
 
         requested_device = self.device
@@ -83,7 +83,7 @@ class TextToSpeech:
         import numpy as np
 
         if self._model is None:
-            self._init_model()
+            self._init_local()
 
         speaker_wav_path: Path | None = None
         cleanup_path = False
@@ -149,7 +149,6 @@ class TextToMusic:
         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."""
@@ -160,17 +159,17 @@ class TextToMusic:
         os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1"
 
         requested_device = self.device
-        self._device = select_device(self.device, mps_allowed=True)
+        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
+        self._model.to(device)
+        self.device = device
         log_device_initialization(
             "TextToMusic",
             requested_device=requested_device,
-            resolved_device=self._device,
+            resolved_device=device,
         )
 
     def generate_audio(self, text: str, max_new_tokens: int = 256) -> Audio:
@@ -179,7 +178,7 @@ class TextToMusic:
             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()}
+        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
 
@@ -193,3 +192,9 @@ class TextToMusic:
             frame_count=len(audio_data),
         )
         return Audio(audio_data, metadata)
+
+    def unload(self) -> None:
+        """Release the MusicGen model so the next generate_audio() re-initializes."""
+        self._model = None
+        self._processor = None
+        release_device_memory(self.device)

{videopython-0.33.0 → videopython-0.33.1}/src/videopython/ai/generation/image.py

@@ -6,7 +6,7 @@ from typing import Any
 
 from PIL import Image
 
-from videopython.ai._device import log_device_initialization, select_device
+from videopython.ai._device import log_device_initialization, release_device_memory, select_device
 
 
 class TextToImage:
@@ -49,3 +49,8 @@ class TextToImage:
         if self._pipeline is None:
             self._init_local()
         return self._pipeline(prompt=prompt).images[0]
+
+    def unload(self) -> None:
+        """Release the diffusion pipeline so the next generate_image() re-initializes."""
+        self._pipeline = None
+        release_device_memory(self.device)

{videopython-0.33.0 → videopython-0.33.1}/src/videopython/ai/generation/translation.py

@@ -181,7 +181,7 @@ class MarianTranslator:
         self._model = MarianMTModel.from_pretrained(model_name).to(device)
         self.device = device
         log_device_initialization(
-            "TextTranslator",
+            "MarianTranslator",
             requested_device=requested_device,
             resolved_device=device,
         )

{videopython-0.33.0 → videopython-0.33.1}/src/videopython/ai/generation/video.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, Any
 
 import numpy as np
 
-from videopython.ai._device import log_device_initialization, select_device
+from videopython.ai._device import log_device_initialization, release_device_memory, select_device
 from videopython.base.video import Video
 
 if TYPE_CHECKING:
@@ -29,22 +29,21 @@ class TextToVideo:
     def __init__(self, device: str | None = None):
         self.device = device
         self._pipeline: Any = None
-        self._device: str | None = None
 
     def _init_local(self) -> None:
         from diffusers import CogVideoXPipeline
 
         requested_device = self.device
-        self._device, dtype = _get_torch_device_and_dtype(self.device)
+        device, dtype = _get_torch_device_and_dtype(self.device)
 
         model_name = "THUDM/CogVideoX1.5-5B"
         self._pipeline = CogVideoXPipeline.from_pretrained(model_name, torch_dtype=dtype)
-        self._pipeline.to(self._device)
-        self.device = self._device
+        self._pipeline.to(device)
+        self.device = device
         log_device_initialization(
             "TextToVideo",
             requested_device=requested_device,
-            resolved_device=self._device,
+            resolved_device=device,
         )
 
     def generate_video(
@@ -65,11 +64,16 @@ class TextToVideo:
             num_inference_steps=num_steps,
             num_frames=num_frames,
             guidance_scale=guidance_scale,
-            generator=torch.Generator(device=self._device).manual_seed(42),
+            generator=torch.Generator(device=self.device).manual_seed(42),
         ).frames[0]
         video_frames = np.asarray(video_frames, dtype=np.uint8)
         return Video.from_frames(video_frames, fps=16.0)
 
+    def unload(self) -> None:
+        """Release the diffusion pipeline so the next generate_video() re-initializes."""
+        self._pipeline = None
+        release_device_memory(self.device)
+
 
 class ImageToVideo:
     """Generates videos from static images using local video diffusion."""
@@ -77,22 +81,21 @@ class ImageToVideo:
     def __init__(self, device: str | None = None):
         self.device = device
         self._pipeline: Any = None
-        self._device: str | None = None
 
     def _init_local(self) -> None:
         from diffusers import CogVideoXImageToVideoPipeline
 
         requested_device = self.device
-        self._device, dtype = _get_torch_device_and_dtype(self.device)
+        device, dtype = _get_torch_device_and_dtype(self.device)
 
         model_name = "THUDM/CogVideoX1.5-5B-I2V"
         self._pipeline = CogVideoXImageToVideoPipeline.from_pretrained(model_name, torch_dtype=dtype)
-        self._pipeline.to(self._device)
-        self.device = self._device
+        self._pipeline.to(device)
+        self.device = device
         log_device_initialization(
             "ImageToVideo",
             requested_device=requested_device,
-            resolved_device=self._device,
+            resolved_device=device,
         )
 
     def generate_video(
@@ -115,7 +118,12 @@ class ImageToVideo:
             num_inference_steps=num_steps,
             num_frames=num_frames,
             guidance_scale=guidance_scale,
-            generator=torch.Generator(device=self._device).manual_seed(42),
+            generator=torch.Generator(device=self.device).manual_seed(42),
         ).frames[0]
         video_frames = np.asarray(video_frames, dtype=np.uint8)
         return Video.from_frames(video_frames, fps=16.0)
+
+    def unload(self) -> None:
+        """Release the diffusion pipeline so the next generate_video() re-initializes."""
+        self._pipeline = None
+        release_device_memory(self.device)

{videopython-0.33.0 → videopython-0.33.1}/src/videopython/ai/understanding/audio.py

@@ -520,6 +520,15 @@ class AudioClassifier:
 
         self._labels = [self._model.config.id2label[i] for i in range(len(self._model.config.id2label))]
 
+    def unload(self) -> None:
+        """Release the AST model so the next classify() re-initializes.
+
+        Used by low-memory dubbing to free VRAM between pipeline stages.
+        """
+        self._model = None
+        self._processor = None
+        release_device_memory(self.device)
+
     def _merge_events(self, events: list[AudioEvent], gap_threshold: float = 0.5) -> list[AudioEvent]:
         """Merge consecutive events of the same class."""
         if not events:

{videopython-0.33.0 → videopython-0.33.1}/src/videopython/ai/understanding/image.py

@@ -11,7 +11,7 @@ from typing import Any, Literal
 import numpy as np
 from PIL import Image
 
-from videopython.ai._device import log_device_initialization, select_device
+from videopython.ai._device import log_device_initialization, release_device_memory, select_device
 from videopython.base.description import SceneDescription
 
 logger = logging.getLogger(__name__)
@@ -190,16 +190,7 @@ class SceneVLM:
         """
         self._model = None
         self._processor = None
-        try:
-            import gc
-
-            import torch
-
-            gc.collect()
-            if torch.cuda.is_available():
-                torch.cuda.empty_cache()
-        except ImportError:
-            pass
+        release_device_memory(self.device)
 
     def _downscale_image(self, img: Image.Image) -> Image.Image:
         """Downscale image to fit within max_image_pixels budget, preserving aspect ratio."""

{videopython-0.33.0 → videopython-0.33.1}/src/videopython/ai/understanding/temporal.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
-from videopython.ai._device import log_device_initialization, select_device
+from videopython.ai._device import log_device_initialization, release_device_memory, select_device
 from videopython.base.description import SceneBoundary
 
 if TYPE_CHECKING:
@@ -56,26 +56,32 @@ class SemanticSceneDetector:
 
         self.threshold = threshold
         self.min_scene_length = min_scene_length
-        self._device: str | None = device
+        self.device: str | None = device
         self._model: Any = None
 
-    def _load_model(self) -> None:
+    def _init_local(self) -> None:
         """Load the TransNetV2 model with pretrained weights."""
         if self._model is not None:
             return
 
         from transnetv2_pytorch import TransNetV2
 
-        requested_device = self._device
-        device = select_device(self._device, mps_allowed=True)
+        requested_device = self.device
+        device = select_device(self.device, mps_allowed=True)
         log_device_initialization(
             "SemanticSceneDetector",
             requested_device=requested_device,
             resolved_device=device,
         )
+        self.device = device
         self._model = TransNetV2(device=device)
         self._model.eval()
 
+    def unload(self) -> None:
+        """Release the TransNetV2 model so the next call re-initializes."""
+        self._model = None
+        release_device_memory(self.device)
+
     def detect(self, video: Video) -> list[SceneBoundary]:
         """Detect scenes in a video using ML-based boundary detection.
 
@@ -114,7 +120,7 @@ class SemanticSceneDetector:
         Returns:
             List of SceneBoundary objects representing detected scenes.
         """
-        self._load_model()
+        self._init_local()
 
         # Use TransNetV2's detect_scenes which handles everything internally
         raw_scenes = self._model.detect_scenes(str(path), threshold=self.threshold)