videopython 0.22.1__tar.gz → 0.22.3__tar.gz

{videopython-0.22.1 → videopython-0.22.3}/PKG-INFO

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

{videopython-0.22.1 → videopython-0.22.3}/pyproject.toml

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

{videopython-0.22.1 → videopython-0.22.3}/src/videopython/base/edit.py

@@ -272,11 +272,51 @@ class VideoEdit:
         return video
 
     def validate(self) -> VideoMetadata:
-        """Validate the editing plan without loading video data."""
+        """Validate the editing plan without loading video data.
+
+        Requires source video files to be present on disk (uses ``VideoMetadata.from_path``).
+        For validation without file access, use :meth:`validate_with_metadata`.
+        """
         segment_metas: list[VideoMetadata] = []
         for i, segment in enumerate(self.segments):
             segment_metas.append(self._validate_segment(i, segment))
+        return self._validate_assembled(segment_metas)
+
+    def validate_with_metadata(
+        self,
+        source_metadata: VideoMetadata | dict[str, VideoMetadata],
+    ) -> VideoMetadata:
+        """Validate the editing plan using pre-built metadata instead of loading from file.
+
+        Same validation as validate() but accepts a VideoMetadata directly,
+        avoiding the need for the source video file to be on disk.
+
+        Args:
+            source_metadata: VideoMetadata for the source video (duration, dimensions, fps).
+                For multi-source plans, pass a dict mapping source paths to their metadata.
+
+        Returns:
+            Predicted output VideoMetadata after all operations.
 
+        Raises:
+            ValueError: If any validation check fails.
+        """
+        if isinstance(source_metadata, VideoMetadata):
+            meta_map: dict[str, VideoMetadata] = {str(seg.source_video): source_metadata for seg in self.segments}
+        else:
+            meta_map = source_metadata
+
+        segment_metas: list[VideoMetadata] = []
+        for i, segment in enumerate(self.segments):
+            source_key = str(segment.source_video)
+            if source_key not in meta_map:
+                raise ValueError(
+                    f"Segment {i}: no metadata provided for source '{source_key}'. Available keys: {sorted(meta_map)}"
+                )
+            segment_metas.append(self._validate_segment_with_metadata(i, segment, meta_map[source_key]))
+        return self._validate_assembled(segment_metas)
+
+    def _validate_assembled(self, segment_metas: list[VideoMetadata]) -> VideoMetadata:
         if len(segment_metas) > 1:
             first = segment_metas[0]
             for j, other in enumerate(segment_metas[1:], start=1):
@@ -343,6 +383,28 @@ class VideoEdit:
             _validate_effect_bounds(record, meta.total_seconds, context=ctx)
         return meta
 
+    def _validate_segment_with_metadata(
+        self, index: int, segment: SegmentConfig, source_meta: VideoMetadata
+    ) -> VideoMetadata:
+        ctx = f"Segment {index}"
+        if segment.start_second < 0:
+            raise ValueError(f"{ctx}: start_second ({segment.start_second}) must be >= 0")
+        if segment.end_second <= segment.start_second:
+            raise ValueError(
+                f"{ctx}: end_second ({segment.end_second}) must be > start_second ({segment.start_second})"
+            )
+        if segment.end_second > source_meta.total_seconds:
+            raise ValueError(
+                f"{ctx}: end_second ({segment.end_second}) exceeds source duration ({source_meta.total_seconds}s)"
+            )
+        meta = source_meta.cut(segment.start_second, segment.end_second)
+
+        for record in segment.transform_records:
+            meta = _predict_transform_metadata(meta, record.op_id, record.args, context=f"{ctx} ({record.op_id})")
+        for record in segment.effect_records:
+            _validate_effect_bounds(record, meta.total_seconds, context=ctx)
+        return meta
+
     def _assemble_segments(self, context: dict[str, Any] | None = None) -> Video:
         result: Video | None = None
         for segment in self.segments:

{videopython-0.22.1 → videopython-0.22.3}/src/videopython/base/effects.py

@@ -582,7 +582,7 @@ class Fade(Effect):
         if video.audio is not None and not video.audio.is_silent:
             sample_rate = video.audio.metadata.sample_rate
             audio_start = round(start_s * sample_rate)
-            audio_end = round(stop_s * sample_rate)
+            audio_end = min(round(stop_s * sample_rate), len(video.audio.data))
             n_audio_samples = audio_end - audio_start
             fade_samples = min(round(self.duration * sample_rate), n_audio_samples)
 
@@ -656,7 +656,7 @@ class VolumeAdjust(AudioEffect):
 
         sample_rate = audio.metadata.sample_rate
         start_sample = round(start * sample_rate)
-        end_sample = round(stop * sample_rate)
+        end_sample = min(round(stop * sample_rate), len(audio.data))
         n_samples = end_sample - start_sample
 
         # Build volume envelope