videopython 0.44.1__tar.gz → 0.45.0__tar.gz

{videopython-0.44.1 → videopython-0.45.0}/PKG-INFO

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

{videopython-0.44.1 → videopython-0.45.0}/pyproject.toml

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

{videopython-0.44.1 → videopython-0.45.0}/src/videopython/base/exceptions.py

@@ -96,7 +96,7 @@ class PlanErrorCode(str, Enum):
     TRANSITION_TOO_LONG = "transition_too_long"
     MUSIC_BED_DUCK_MULTISEGMENT = "music_bed_duck_multisegment"
     # Streaming: unstreamable op at its plan position (always reported).
-    STREAMING_FALLBACK = "streaming_fallback"
+    STREAMING_UNSUPPORTED = "streaming_unsupported"
 
 
 @dataclass

{videopython-0.44.1 → videopython-0.45.0}/src/videopython/editing/streaming.py

@@ -36,8 +36,8 @@ class StreamingClass(str, Enum):
 
     ``FILTER`` and ``FRAME_EFFECT`` stream in O(1) memory w.r.t. video
     length. ``UNSTREAMABLE`` means the op (or its plan position) has no
-    streaming strategy; since streaming is the only engine, such plans are
-    rejected with structured ``STREAMING_FALLBACK`` errors instead of run.
+    streaming strategy; such plans are rejected with structured
+    ``STREAMING_UNSUPPORTED`` errors.
     """
 
     FILTER = "filter"
@@ -85,19 +85,19 @@ class StreamabilityReport:
         return all(e.streams for e in self.entries)
 
     @property
-    def fallbacks(self) -> tuple[OpStreamability, ...]:
+    def unstreamable(self) -> tuple[OpStreamability, ...]:
         """The unstreamable ops, in plan order."""
         return tuple(e for e in self.entries if not e.streams)
 
     def errors(self) -> list[PlanError]:
-        """The fallbacks as structured ``STREAMING_FALLBACK`` plan errors.
+        """The unstreamable ops as structured ``STREAMING_UNSUPPORTED`` plan errors.
 
         The same shape :meth:`VideoEdit.check` returns, so an LLM refine loop
         can treat "would not stream" exactly like any other plan violation.
         """
         return [
-            PlanError(code=PlanErrorCode.STREAMING_FALLBACK, location=e.location, op=e.op, detail=e.reason)
-            for e in self.fallbacks
+            PlanError(code=PlanErrorCode.STREAMING_UNSUPPORTED, location=e.location, op=e.op, detail=e.reason)
+            for e in self.unstreamable
         ]
 
 
@@ -115,7 +115,7 @@ def analyze_streamability(
     ``streamable`` ClassVar as the authoritative declaration (a flag-False
     transform never streams, even with a working ``to_ffmpeg_filter``); the
     one divergence the flag cannot express -- flag True but the filter
-    compiles to ``None`` -- is caught at runtime by the ``STREAMING_FALLBACK``
+    compiles to ``None`` -- is caught at runtime by the ``STREAMING_UNSUPPORTED``
     raise in ``_compile_streaming_plans``, and a registry test pins flag-True
     transforms to an actual ``to_ffmpeg_filter`` override. Purely structural:
     no disk access and no runtime context.

{videopython-0.44.1 → videopython-0.45.0}/src/videopython/editing/video_edit.py

@@ -1036,7 +1036,7 @@ class VideoEdit(BaseModel):
         :meth:`validate`: a clampable ``window.stop`` overrun is not reported.
 
         Streaming is the only engine, so ops that cannot stream at their
-        plan position are real plan errors: one ``STREAMING_FALLBACK`` per
+        plan position are real plan errors: one ``STREAMING_UNSUPPORTED`` per
         offending op is appended after the validity errors, in plan order,
         with the actionable cause in :attr:`PlanError.detail`. See
         :meth:`streamability` for the full per-op report including the ops
@@ -1056,7 +1056,7 @@ class VideoEdit(BaseModel):
         admitted. ``report.streamable`` answers "will :meth:`run_to_file`
         stream this plan in O(1) memory, or is an op unstreamable at its
         plan position?"; each entry carries the op's memory class and, for
-        fallbacks, the reason.
+        unstreamable ops, the reason.
         """
         return analyze_streamability(
             [list(seg.operations) for seg in self.segments],
@@ -1603,7 +1603,7 @@ class VideoEdit(BaseModel):
         Memory usage is O(1) w.r.t. video length (video; segment audio is
         in-memory). Streaming is the only engine: a plan with an unstreamable
         shape raises :class:`PlanValidationError` carrying one
-        ``STREAMING_FALLBACK`` :class:`PlanError` per offending op -- before
+        ``STREAMING_UNSUPPORTED`` :class:`PlanError` per offending op -- before
         any decode. Gate plans early with :meth:`check` or
         :meth:`streamability`, which report the same errors without running
         anything.
@@ -1834,16 +1834,16 @@ class VideoEdit(BaseModel):
         :class:`PlanValidationError` with the streamability report's
         structured errors; a builder/report drift (e.g. a third-party
         transform whose ``streamable`` flag does not match its
-        ``to_ffmpeg_filter``) raises with a generic ``STREAMING_FALLBACK``.
+        ``to_ffmpeg_filter``) raises with a generic ``STREAMING_UNSUPPORTED``.
         On raise, any compile-time temp files already created are deleted;
         on success the caller owns ``plan.owned_temp_files``.
         """
         self._assert_post_ops_supported(context)
         report = self.streamability()
         if not report.streamable:
-            causes = "; ".join(f"{e.location} '{e.op}': {e.reason}" for e in report.fallbacks)
+            causes = "; ".join(f"{e.location} '{e.op}': {e.reason}" for e in report.unstreamable)
             message = (
-                f"Plan cannot stream: {len(report.fallbacks)} op(s) have no streaming "
+                f"Plan cannot stream: {len(report.unstreamable)} op(s) have no streaming "
                 f"strategy at their plan position -- {causes}"
             )
             raise PlanValidationError(message, report.errors())
@@ -1851,7 +1851,7 @@ class VideoEdit(BaseModel):
         def drift(detail: str) -> PlanValidationError:
             return PlanValidationError(
                 f"plan stopped streaming despite a clean streamability report ({detail})",
-                [PlanError(code=PlanErrorCode.STREAMING_FALLBACK, detail=detail)],
+                [PlanError(code=PlanErrorCode.STREAMING_UNSUPPORTED, detail=detail)],
             )
 
         target_fps, target_w, target_h = self._matching_targets_from_disk()
@@ -2090,7 +2090,7 @@ class VideoEdit(BaseModel):
                 # flag-False transform is classified UNSTREAMABLE even if it has
                 # a working to_ffmpeg_filter. The remaining drift class (flag
                 # True, filter compiles to None) is caught by the
-                # STREAMING_FALLBACK raise in _compile_streaming_plans.
+                # STREAMING_UNSUPPORTED raise in _compile_streaming_plans.
                 if not op.streamable:
                     abandon()
                     return None