videopython 0.22.0__tar.gz → 0.22.2__tar.gz

{videopython-0.22.0 → videopython-0.22.2}/PKG-INFO

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

{videopython-0.22.0 → videopython-0.22.2}/pyproject.toml

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

{videopython-0.22.0 → videopython-0.22.2}/src/videopython/ai/understanding/audio.py

@@ -59,7 +59,7 @@ class AudioToText:
             )
             transcription_segments.append(transcription_segment)
 
-        return Transcription(segments=transcription_segments)
+        return Transcription(segments=transcription_segments, language=transcription_result.get("language"))
 
     def _process_whisperx_result(self, whisperx_result: dict, audio_data) -> Transcription:
         """Process whisperx result with diarization."""
@@ -94,7 +94,7 @@ class AudioToText:
                 )
             )
 
-        return Transcription(words=words)
+        return Transcription(words=words, language=whisperx_result.get("language"))
 
     def _transcribe_local(self, audio: Audio) -> Transcription:
         """Transcribe using local Whisper model."""

{videopython-0.22.0 → videopython-0.22.2}/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.0 → videopython-0.22.2}/src/videopython/base/text/transcription.py

@@ -67,12 +67,14 @@ class Transcription:
         self,
         segments: list[TranscriptionSegment] | None = None,
         words: list[TranscriptionWord] | None = None,
+        language: str | None = None,
     ):
         """Initialize Transcription from either segments or words.
 
         Args:
             segments: Pre-constructed segments (backward compatible)
             words: Words to group into segments by speaker (for diarization)
+            language: ISO 639-1 language code detected during transcription (e.g. "en", "pl")
 
         Raises:
             ValueError: If both or neither arguments are provided
@@ -80,6 +82,8 @@ class Transcription:
         if (segments is None) == (words is None):
             raise ValueError("Exactly one of 'segments' or 'words' must be provided")
 
+        self.language = language
+
         if segments is not None:
             self.segments = segments
             self.speakers = {s.speaker for s in segments if s.speaker is not None}
@@ -185,7 +189,7 @@ class Transcription:
                 )
             )
 
-        return Transcription(segments=offset_segments)
+        return Transcription(segments=offset_segments, language=self.language)
 
     def standardize_segments(self, *, time: float | None = None, num_words: int | None = None) -> Transcription:
         """Return a new Transcription with standardized segments.
@@ -212,7 +216,7 @@ class Transcription:
             all_words.extend(segment.words)
 
         if not all_words:
-            return Transcription(segments=[])
+            return Transcription(segments=[], language=self.language)
 
         standardized_segments = []
 
@@ -266,7 +270,7 @@ class Transcription:
                     )
                 )
 
-        return Transcription(segments=standardized_segments)
+        return Transcription(segments=standardized_segments, language=self.language)
 
     def slice(self, start: float, end: float) -> Transcription | None:
         """Return a new Transcription containing only words within the time range.
@@ -334,15 +338,19 @@ class Transcription:
                 )
             )
 
-        return Transcription(segments=sliced_segments)
+        return Transcription(segments=sliced_segments, language=self.language)
 
     def to_dict(self) -> dict:
         """Convert to dictionary for JSON serialization."""
         return {
             "segments": [s.to_dict() for s in self.segments],
+            "language": self.language,
         }
 
     @classmethod
     def from_dict(cls, data: dict) -> Transcription:
         """Create Transcription from dictionary."""
-        return cls(segments=[TranscriptionSegment.from_dict(s) for s in data["segments"]])
+        return cls(
+            segments=[TranscriptionSegment.from_dict(s) for s in data["segments"]],
+            language=data.get("language"),
+        )