Move more stuff out of Scene

Author: eulertour

manim/renderer/cairo_renderer.py

@@ -1,14 +1,108 @@
 import numpy as np
-from .. import file_writer_config
+from .. import camera_config, file_writer_config, logger
 from ..utils.iterables import list_update
 from ..utils.exceptions import EndSceneEarlyException
+from ..utils.hashing import get_hash_from_play_call, get_hash_from_wait_call
+from ..constants import DEFAULT_WAIT_TIME
+
+
+def handle_caching_play(func):
+    """
+    Decorator that returns a wrapped version of func that will compute the hash of the play invocation.
+
+    The returned function will act according to the computed hash: either skip the animation because it's already cached, or let the invoked function play normally.
+
+    Parameters
+    ----------
+    func : Callable[[...], None]
+        The play like function that has to be written to the video file stream. Take the same parameters as `scene.play`.
+    """
+
+    def wrapper(self, *args, **kwargs):
+        self.revert_to_original_skipping_status()
+        self.update_skipping_status()
+        animations = self.scene.compile_play_args_to_animation_list(*args, **kwargs)
+        self.scene.add_mobjects_from_animations(animations)
+        if file_writer_config["skip_animations"]:
+            logger.debug(f"Skipping animation {self.num_plays}")
+            func(self, *args, **kwargs)
+            return
+        if not file_writer_config["disable_caching"]:
+            mobjects_on_scene = self.scene.get_mobjects()
+            hash_play = get_hash_from_play_call(
+                self, self.camera, animations, mobjects_on_scene
+            )
+            self.play_hashes_list.append(hash_play)
+            if self.file_writer.is_already_cached(hash_play):
+                logger.info(
+                    f"Animation {self.num_plays} : Using cached data (hash : %(hash_play)s)",
+                    {"hash_play": hash_play},
+                )
+                file_writer_config["skip_animations"] = True
+        else:
+            hash_play = "uncached_{:05}".format(self.num_plays)
+            self.play_hashes_list.append(hash_play)
+        func(self, *args, **kwargs)
+
+    return wrapper
+
+
+def handle_play_like_call(func):
+    """
+    This method is used internally to wrap the
+    passed function, into a function that
+    actually writes to the video stream.
+    Simultaneously, it also adds to the number
+    of animations played.
+
+    Parameters
+    ----------
+    func : function
+        The play() like function that has to be
+        written to the video file stream.
+
+    Returns
+    -------
+    function
+        The play() like function that can now write
+        to the video file stream.
+    """
+
+    def wrapper(self, *args, **kwargs):
+        allow_write = not file_writer_config["skip_animations"]
+        self.file_writer.begin_animation(allow_write)
+        func(self, *args, **kwargs)
+        self.file_writer.end_animation(allow_write)
+        self.num_plays += 1
+
+    return wrapper
 
 
 class CairoRenderer:
+    """A renderer using Cairo.
+
+    num_plays : Number of play() functions in the scene.
+    time: time elapsed since initialisation of scene.
+    """
+
     def __init__(self, scene, camera, file_writer):
-        self.scene = scene
         self.camera = camera
         self.file_writer = file_writer
+        self.scene = scene
+        self.original_skipping_status = file_writer_config["skip_animations"]
+        self.play_hashes_list = []
+        self.num_plays = 0
+        self.time = 0
+
+    @handle_caching_play
+    @handle_play_like_call
+    def play(self, *args, **kwargs):
+        self.scene.play_internal(*args, **kwargs)
+
+    @handle_caching_play
+    @handle_play_like_call
+    def wait(self, duration=DEFAULT_WAIT_TIME, stop_condition=None):
+        self.scene.wait_internal(duration=duration, stop_condition=stop_condition)
 
     def update_frame(  # TODO Description in Docstring
         self,
@@ -74,12 +168,20 @@ def add_frame(self, frame, num_frames=1):
             The number of times to add frame.
         """
         dt = 1 / self.camera.frame_rate
-        self.scene.increment_time(num_frames * dt)
+        self.time += num_frames * dt
         if file_writer_config["skip_animations"]:
             return
         for _ in range(num_frames):
             self.file_writer.write_frame(frame)
 
+    def show_frame(self):
+        """
+        Opens the current frame in the Default Image Viewer
+        of your system.
+        """
+        self.update_frame(ignore_skipping=True)
+        self.camera.get_image().show()
+
     def update_skipping_status(self):
         """
         This method is used internally to check if the current
@@ -89,17 +191,29 @@ def update_skipping_status(self):
         raises an EndSceneEarlyException if they don't correspond.
         """
         if file_writer_config["from_animation_number"]:
-            if self.scene.num_plays < file_writer_config["from_animation_number"]:
+            if self.num_plays < file_writer_config["from_animation_number"]:
                 file_writer_config["skip_animations"] = True
         if file_writer_config["upto_animation_number"]:
-            if self.scene.num_plays > file_writer_config["upto_animation_number"]:
+            if self.num_plays > file_writer_config["upto_animation_number"]:
                 file_writer_config["skip_animations"] = True
                 raise EndSceneEarlyException()
 
-    def show_frame(self):
+    def revert_to_original_skipping_status(self):
         """
-        Opens the current frame in the Default Image Viewer
-        of your system.
+        Forces the scene to go back to its original skipping status,
+        by setting skip_animations to whatever it reads
+        from original_skipping_status.
+
+        Returns
+        -------
+        Scene
+            The Scene, with the original skipping status.
         """
-        self.update_frame(ignore_skipping=True)
-        self.camera.get_image().show()
+        if hasattr(self, "original_skipping_status"):
+            file_writer_config["skip_animations"] = self.original_skipping_status
+        return self
+
+    def finish(self):
+        file_writer_config["skip_animations"] = False
+        self.file_writer.finish()
+        logger.info(f"Rendered {str(self.scene)}\nPlayed {self.num_plays} animations")

manim/scene/scene.py

@@ -52,8 +52,6 @@ def construct(self):
         file_writer : The object that writes the animations in the scene to a video file.
         mobjects : The list of mobjects present in the scene.
         foreground_mobjects : List of mobjects explicitly in the foreground.
-        num_plays : Number of play() functions in the scene.
-        time: time elapsed since initialisation of scene.
         random_seed: The seed with which all random operations are done.
 
     """
@@ -73,15 +71,10 @@ def __init__(self, **kwargs):
             **file_writer_config,
         )
         self.renderer = CairoRenderer(self, self.camera, self.file_writer)
-        self.play_hashes_list = []
 
         self.mobjects = []
-        self.original_skipping_status = file_writer_config["skip_animations"]
         # TODO, remove need for foreground mobjects
         self.foreground_mobjects = []
-        self.num_plays = 0
-        self.time = 0
-        self.original_skipping_status = file_writer_config["skip_animations"]
         if self.random_seed is not None:
             random.seed(self.random_seed)
             np.random.seed(self.random_seed)
@@ -96,13 +89,8 @@ def render(self):
             self.construct()
         except EndSceneEarlyException:
             pass
-
         self.tear_down()
-        # We have to reset these settings in case of multiple renders.
-        file_writer_config["skip_animations"] = False
-
-        self.file_writer.finish()
-        self.print_end_message()
+        self.renderer.finish()
 
     def setup(self):
         """
@@ -130,15 +118,6 @@ def construct(self):
     def __str__(self):
         return self.__class__.__name__
 
-    def print_end_message(self):
-        """
-        Used internally to print the number of
-        animations played after the scene ends,
-        as well as the name of the scene rendered
-        (useful when using the `-a` option).
-        """
-        logger.info(f"Rendered {str(self)}\nPlayed {self.num_plays} animations")
-
     def set_variables_as_attrs(self, *objects, **newly_named_objects):
         """
         This method is slightly hacky, making it a little easier
@@ -199,18 +178,6 @@ def should_update_mobjects(self):
 
     ###
 
-    def increment_time(self, d_time):
-        """
-        Increments the time elapsed after intialisation of scene by
-        passed "d_time".
-
-        Parameters
-        ----------
-        d_time : int or float
-            Time in seconds to increment by.
-        """
-        self.time += d_time
-
     ###
 
     def get_top_level_mobjects(self):
@@ -646,7 +613,7 @@ def get_animation_time_progression(self, animations):
         time_progression.set_description(
             "".join(
                 [
-                    "Animation {}: ".format(self.num_plays),
+                    "Animation {}: ".format(self.renderer.num_plays),
                     str(animations[0]),
                     (", etc." if len(animations) > 1 else ""),
                 ]
@@ -799,66 +766,10 @@ def finish_animations(self, animations):
             self.update_mobjects(0)
 
     def wait(self, duration=DEFAULT_WAIT_TIME, stop_condition=None):
-        self.play(duration=duration, stop_condition=stop_condition)
+        self.renderer.wait(duration=duration, stop_condition=stop_condition)
 
     def play(self, *args, **kwargs):
-        self.cached_play(*args, **kwargs)
-        self.num_plays += 1
-
-    def revert_to_original_skipping_status(self):
-        """
-        Forces the scene to go back to its original skipping status,
-        by setting skip_animations to whatever it reads
-        from original_skipping_status.
-
-        Returns
-        -------
-        Scene
-            The Scene, with the original skipping status.
-        """
-        if hasattr(self, "original_skipping_status"):
-            file_writer_config["skip_animations"] = self.original_skipping_status
-        return self
-
-    def cached_play(self, *args, **kwargs):
-        self.revert_to_original_skipping_status()
-        self.renderer.update_skipping_status()
-        animations = self.compile_play_args_to_animation_list(*args, **kwargs)
-        self.add_mobjects_from_animations(animations)
-        if file_writer_config["skip_animations"]:
-            logger.debug(f"Skipping animation {self.num_plays}")
-            self.file_writer_wrapped_play(*args, **kwargs)
-            return
-        if not file_writer_config["disable_caching"]:
-            mobjects_on_scene = self.get_mobjects()
-            hash_play = get_hash_from_play_call(
-                self, self.camera, animations, mobjects_on_scene
-            )
-            self.play_hashes_list.append(hash_play)
-            if self.file_writer.is_already_cached(hash_play):
-                logger.info(
-                    f"Animation {self.num_plays} : Using cached data (hash : %(hash_play)s)",
-                    {"hash_play": hash_play},
-                )
-                file_writer_config["skip_animations"] = True
-        else:
-            hash_play = "uncached_{:05}".format(self.num_plays)
-            self.play_hashes_list.append(hash_play)
-        self.file_writer_wrapped_play(*args, **kwargs)
-
-    def file_writer_wrapped_play(self, *args, **kwargs):
-        allow_write = not file_writer_config["skip_animations"]
-        self.file_writer.begin_animation(allow_write)
-
-        self.play_or_wait(*args, **kwargs)
-
-        self.file_writer.end_animation(allow_write)
-
-    def play_or_wait(self, *args, **kwargs):
-        if "duration" in kwargs:
-            self.wait_internal(**kwargs)
-        else:
-            self.play_internal(*args, **kwargs)
+        self.renderer.play(*args, **kwargs)
 
     def play_internal(self, *args, **kwargs):
         """
@@ -969,7 +880,9 @@ def get_wait_time_progression(self, duration, stop_condition):
             )
         else:
             time_progression = self.get_time_progression(duration)
-            time_progression.set_description("Waiting {}".format(self.num_plays))
+            time_progression.set_description(
+                "Waiting {}".format(self.renderer.num_plays)
+            )
         return time_progression
 
     def wait_until(self, stop_condition, max_time=60):

manim/scene/scene_file_writer.py

@@ -202,7 +202,7 @@ def get_next_partial_movie_path(self):
         result = os.path.join(
             self.partial_movie_directory,
             "{}{}".format(
-                self.scene.play_hashes_list[self.index_partial_movie_file],
+                self.scene.renderer.play_hashes_list[self.index_partial_movie_file],
                 file_writer_config["movie_file_extension"],
             ),
         )
@@ -461,7 +461,7 @@ def close_movie_pipe(self):
             self.partial_movie_file_path,
         )
         logger.info(
-            f"Animation {self.scene.num_plays} : Partial movie file written in %(path)s",
+            f"Animation {self.scene.renderer.num_plays} : Partial movie file written in %(path)s",
             {"path": {self.partial_movie_file_path}},
         )
 
@@ -502,7 +502,7 @@ def combine_movie_files(self):
                 self.partial_movie_directory,
                 "{}{}".format(hash_play, file_writer_config["movie_file_extension"]),
             )
-            for hash_play in self.scene.play_hashes_list
+            for hash_play in self.scene.renderer.play_hashes_list
         ]
         if len(partial_movie_files) == 0:
             logger.error("No animations in this scene")

tests/control_data/logs_data/BasicSceneLoggingTest.txt

@@ -3,4 +3,4 @@
 {"levelname": "DEBUG", "module": "hashing", "message": "Hashing done in <> s."}
 {"levelname": "INFO", "module": "scene_file_writer", "message": "Animation 0 : Partial movie file written in <>"}
 {"levelname": "INFO", "module": "scene_file_writer", "message": "\nFile ready at <>\n"}
-{"levelname": "INFO", "module": "scene", "message": "Rendered SquareToCircle\nPlayed 1 animations"}
+{"levelname": "INFO", "module": "cairo_renderer", "message": "Rendered SquareToCircle\nPlayed 1 animations"}