Move validate_run_time to Scene and fix some tests in test_animation.py

Author: chopan050

manim/animation/animation.py

@@ -12,7 +12,7 @@
 
 from manim.mobject.opengl.opengl_mobject import OpenGLMobject
 
-from .. import config, logger
+from .. import logger
 from ..mobject import mobject
 from ..mobject.mobject import Group, Mobject
 from ..mobject.opengl import opengl_mobject
@@ -224,7 +224,6 @@ def begin(self) -> None:
         method.
 
         """
-        self.run_time = validate_run_time(self.run_time, str(self))
         self.starting_mobject = self.create_starting_mobject()
         if self.suspend_mobject_updating:
             # All calls to self.mobject's internal updaters
@@ -567,33 +566,6 @@ def prepare_animation(
         raise TypeError(f"Object {anim} cannot be converted to an animation") from None
 
 
-def validate_run_time(
-    run_time: float, caller_name: str, parameter_name: str = "run_time"
-) -> float:
-    if run_time <= 0:
-        raise ValueError(
-            f"{caller_name} has a {parameter_name} of {run_time:g} <= 0 "
-            f"seconds which Manim cannot render. Please set the "
-            f"{parameter_name} to a positive number."
-        )
-
-    # config.frame_rate holds the number of frames per second
-    fps = config.frame_rate
-    seconds_per_frame = 1 / fps
-    if run_time < seconds_per_frame:
-        logger.warning(
-            f"The original {parameter_name} of {caller_name}, {run_time:g} "
-            f"seconds, is too short for the current frame rate of {fps:g} "
-            f"FPS. Rendering with the shortest possible {parameter_name} of "
-            f"{seconds_per_frame:g} seconds instead."
-        )
-        new_run_time = seconds_per_frame
-    else:
-        new_run_time = run_time
-
-    return new_run_time
-
-
 class Wait(Animation):
     """A "no operation" animation.
 
@@ -633,7 +605,7 @@ def __init__(
         super().__init__(None, run_time=run_time, rate_func=rate_func, **kwargs)
 
     def begin(self) -> None:
-        self.run_time = validate_run_time(self.run_time, str(self))
+        pass
 
     def finish(self) -> None:
         pass

manim/animation/composition.py

@@ -8,7 +8,7 @@
 import numpy as np
 
 from manim._config import config
-from manim.animation.animation import Animation, prepare_animation, validate_run_time
+from manim.animation.animation import Animation, prepare_animation
 from manim.constants import RendererType
 from manim.mobject.mobject import Group, Mobject
 from manim.mobject.opengl.opengl_mobject import OpenGLGroup
@@ -93,7 +93,6 @@ def begin(self) -> None:
             anim.begin()
             self.process_subanimation_buffer(anim.buffer)
 
-        self.run_time = validate_run_time(self.run_time, str(self))
         self.anim_group_time = 0.0
         if self.suspend_mobject_updating:
             self.group.suspend_updating()
@@ -238,7 +237,6 @@ def begin(self) -> None:
                 f"Trying to play {self} without animations, this is not supported. "
                 "Please add at least one subanimation."
             )
-        self.run_time = validate_run_time(self.run_time, str(self))
         self.update_active_animation(0)
 
     def finish(self) -> None:

manim/scene/scene.py

@@ -10,7 +10,7 @@
 from typing_extensions import assert_never
 
 from manim import config, logger
-from manim.animation.animation import prepare_animation, validate_run_time
+from manim.animation.animation import prepare_animation
 from manim.animation.scene_buffer import SceneBuffer, SceneOperation
 from manim.camera.camera import Camera
 from manim.constants import DEFAULT_WAIT_TIME
@@ -353,6 +353,35 @@ def finish_animations(self, animations: Iterable[AnimationProtocol]) -> None:
             animation.finish()
             self.process_buffer(animation.buffer)
 
+    @classmethod
+    def validate_run_time(
+        cls,
+        run_time: float,
+        method: Callable[[Any, ...], Any],
+        parameter_name: str = "run_time",
+    ) -> float:
+        method_name = f"{cls.__name__}.{method.__name__}()"
+        if run_time <= 0:
+            raise ValueError(
+                f"{method_name} has a {parameter_name} of "
+                f"{run_time:g} <= 0 seconds which Manim cannot render. "
+                f"The {parameter_name} must be a positive number."
+            )
+
+        # config.frame_rate holds the number of frames per second
+        fps = config.frame_rate
+        seconds_per_frame = 1 / fps
+        if run_time < seconds_per_frame:
+            logger.warning(
+                f"The original {parameter_name} of {method_name}, "
+                f"{run_time:g} seconds, is too short for the current frame "
+                f"rate of {fps:g} FPS. Rendering with the shortest possible "
+                f"{parameter_name} of {seconds_per_frame:g} seconds instead."
+            )
+            run_time = seconds_per_frame
+
+        return run_time
+
     def play(
         self,
         # the OpenGLMobject is a side-effect of the return type of animate, it will
@@ -367,11 +396,21 @@ def play(
         if len(proto_animations) == 0:
             logger.warning("Called Scene.play with no animations")
             return
-        # build animationbuilders
+
+        # Build _AnimationBuilders.
         animations = [prepare_animation(x) for x in proto_animations]
         for anim in animations:
             anim.update_rate_info(run_time, rate_func, lag_ratio)
 
+        # Validate the final run_time.
+        total_run_time = max(anim.get_run_time() for anim in animations)
+        new_total_run_time = self.validate_run_time(
+            total_run_time, self.play, "total run_time"
+        )
+        if new_total_run_time != total_run_time:
+            for anim in animations:
+                anim.update_rate_info(new_total_run_time)
+
         # NOTE: Should be changed at some point with the 2 pass rendering system 21.06.2024
         self.manager._play(*animations)
 
@@ -382,7 +421,7 @@ def wait(
         note: str | None = None,
         ignore_presenter_mode: bool = False,
     ):
-        duration = validate_run_time(duration, str(self) + ".wait()", "duration")
+        duration = self.validate_run_time(duration, self.wait, "duration")
         self.manager._wait(duration, stop_condition=stop_condition)
         # if (
         #     self.presenter_mode
@@ -394,7 +433,7 @@ def wait(
         #     self.hold_loop()
 
     def wait_until(self, stop_condition: Callable[[], bool], max_time: float = 60):
-        max_time = validate_run_time(max_time, str(self) + ".wait_until()", "max_time")
+        max_time = self.validate_run_time(max_time, self.wait_until, "max_time")
         self.wait(max_time, stop_condition=stop_condition)
 
     def add_sound(

tests/module/animation/test_animation.py

@@ -58,6 +58,7 @@ def test_pause_invalid_duration(duration):
 
 @pytest.mark.parametrize("max_time", [0, -1])
 def test_wait_until_invalid_max_time(max_time):
-    test_scene = Manager(Scene)
+    manager = Manager(Scene)
+    test_scene = manager.scene
     with pytest.raises(ValueError, match="The max_time must be a positive number."):
         test_scene.wait_until(lambda: True, max_time)