Merge remote-tracking branch 'origin/master' into renderer-refactor

Author: eulertour

manim/renderer/cairo_renderer.py

@@ -27,13 +27,16 @@ def wrapper(self, *args, **kwargs):
         if file_writer_config["skip_animations"]:
             logger.debug(f"Skipping animation {self.num_plays}")
             func(self, *args, **kwargs)
+            # If the animation is skipped, we mark its hash as None.
+            # When sceneFileWriter will start combining partial movie files, it won't take into account None hashes.
+            self.animations_hashes.append(None)
+            self.file_writer.add_partial_movie_file(None)
             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)",
@@ -42,12 +45,62 @@ def wrapper(self, *args, **kwargs):
                 file_writer_config["skip_animations"] = True
         else:
             hash_play = "uncached_{:05}".format(self.num_plays)
-            self.play_hashes_list.append(hash_play)
+        self.animations_hashes.append(hash_play)
+        self.file_writer.add_partial_movie_file(hash_play)
+        logger.debug(
+            "List of the first few animation hashes of the scene: %(h)s",
+            {"h": str(self.animations_hashes[:5])},
+        )
         func(self, *args, **kwargs)
 
     return wrapper
 
 
+def handle_caching_wait(func):
+    """
+    Decorator that returns a wrapped version of func that will compute the hash of the wait 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 wait like function that has to be written to the video file stream. Take the same parameters as `scene.wait`.
+    """
+
+    def wrapper(self, duration=DEFAULT_WAIT_TIME, stop_condition=None):
+        self.revert_to_original_skipping_status()
+        self.update_skipping_status()
+        if file_writer_config["skip_animations"]:
+            logger.debug(f"Skipping wait {self.num_plays}")
+            func(self, duration, stop_condition)
+            # If the animation is skipped, we mark its hash as None.
+            # When sceneFileWriter will start combining partial movie files, it won't take into account None hashes.
+            self.animations_hashes.append(None)
+            self.file_writer.add_partial_movie_file(None)
+            return
+        if not file_writer_config["disable_caching"]:
+            hash_wait = get_hash_from_wait_call(
+                self, self.camera, duration, stop_condition, self.get_mobjects()
+            )
+            if self.file_writer.is_already_cached(hash_wait):
+                logger.info(
+                    f"Wait {self.num_plays} : Using cached data (hash : {hash_wait})"
+                )
+                file_writer_config["skip_animations"] = True
+        else:
+            hash_wait = "uncached_{:05}".format(self.num_plays)
+        self.animations_hashes.append(hash_wait)
+        self.file_writer.add_partial_movie_file(hash_wait)
+        logger.debug(
+            "Animations hashes list of the scene : (concatened to 5) %(h)s",
+            {"h": str(self.animations_hashes[:5])},
+        )
+        func(self, duration, stop_condition)
+
+    return wrapper
+
+
 def handle_play_like_call(func):
     """
     This method is used internally to wrap the
@@ -110,7 +163,7 @@ def __init__(self, scene, camera_class, **kwargs):
         )
         self.scene = scene
         self.original_skipping_status = file_writer_config["skip_animations"]
-        self.play_hashes_list = []
+        self.animations_hashes = []
         self.num_plays = 0
         self.time = 0
 

manim/scene/scene_file_writer.py

@@ -37,6 +37,9 @@ class SceneFileWriter(object):
             The PIL image mode to use when outputting PNGs
         "movie_file_extension" (str=".mp4")
             The file-type extension of the outputted video.
+        "partial_movie_files"
+            List of all the partial-movie files.
+
     """
 
     def __init__(self, video_quality_config, scene, **kwargs):
@@ -47,7 +50,7 @@ def __init__(self, video_quality_config, scene, **kwargs):
         self.init_output_directories()
         self.init_audio()
         self.frame_count = 0
-        self.index_partial_movie_file = 0
+        self.partial_movie_files = []
 
     # Output directories and files
     def init_output_directories(self):
@@ -114,6 +117,29 @@ def init_output_directories(self):
                     )
                 )
 
+    def add_partial_movie_file(self, hash_animation):
+        """Adds a new partial movie file path to scene.partial_movie_files from an hash. This method will compute the path from the hash.
+
+        Parameters
+        ----------
+        hash_animation : str
+            Hash of the animation.
+        """
+
+        # None has to be added to partial_movie_files to keep the right index with scene.num_plays.
+        # i.e if an animation is skipped, scene.num_plays is still incremented and we add an element to partial_movie_file be even with num_plays.
+        if hash_animation is None:
+            self.partial_movie_files.append(None)
+            return
+        new_partial_movie_file = os.path.join(
+            self.partial_movie_directory,
+            "{}{}".format(
+                hash_animation,
+                file_writer_config["movie_file_extension"],
+            ),
+        )
+        self.partial_movie_files.append(new_partial_movie_file)
+
     def get_default_module_directory(self):
         """
         This method gets the name of the directory containing
@@ -150,7 +176,7 @@ def get_resolution_directory(self):
         This method gets the name of the directory that immediately contains the
         video file. This name is ``<height_in_pixels_of_video>p<frame_rate>``.
         For example, if you are rendering an 854x480 px animation at 15fps,
-        the name of the directory that immediately contains the video file
+        the name of the directory that immediately contains the video,  file
         will be ``480p15``.
 
         The file structure should look something like::
@@ -187,29 +213,6 @@ def get_image_file_path(self):
         """
         return self.image_file_path
 
-    def get_next_partial_movie_path(self):
-        """
-        Manim renders each play-like call in a short partial
-        video file. All such files are then concatenated with
-        the help of FFMPEG.
-
-        This method returns the path of the next partial movie.
-
-        Returns
-        -------
-        str
-            The path of the next partial movie.
-        """
-        result = os.path.join(
-            self.partial_movie_directory,
-            "{}{}".format(
-                self.scene.renderer.play_hashes_list[self.index_partial_movie_file],
-                file_writer_config["movie_file_extension"],
-            ),
-        )
-        self.index_partial_movie_file += 1
-        return result
-
     def get_movie_file_path(self):
         """
         Returns the final path of the written video file.
@@ -397,7 +400,9 @@ def open_movie_pipe(self):
         FFMPEG and begin writing to FFMPEG's input
         buffer.
         """
-        file_path = self.get_next_partial_movie_path()
+        file_path = self.partial_movie_files[self.scene.renderer.num_plays]
+
+        # TODO #486 Why does ffmpeg need temp files ?
         temp_file_path = (
             os.path.splitext(file_path)[0]
             + "_temp"
@@ -495,21 +500,20 @@ def combine_movie_files(self):
         # cuts at all the places you might want.  But for viewing
         # the scene as a whole, one of course wants to see it as a
         # single piece.
-        partial_movie_files = [
-            os.path.join(
-                self.partial_movie_directory,
-                "{}{}".format(hash_play, file_writer_config["movie_file_extension"]),
-            )
-            for hash_play in self.scene.renderer.play_hashes_list
-        ]
-        if len(partial_movie_files) == 0:
-            logger.error("No animations in this scene")
-            return
+        partial_movie_files = [el for el in self.partial_movie_files if el is not None]
+        # NOTE : Here we should do a check and raise an exeption if partial movie file is empty.
+        # We can't, as a lot of stuff (in particular, in tests) use scene initialization, and this error would be raised as it's just
+        # an empty scene initialized.
+
         # Write a file partial_file_list.txt containing all
         # partial movie files. This is used by FFMPEG.
         file_list = os.path.join(
             self.partial_movie_directory, "partial_movie_file_list.txt"
         )
+        logger.debug(
+            f"Partial movie files to combine ({len(partial_movie_files)} files): %(p)s",
+            {"p": partial_movie_files[:5]},
+        )
         with open(file_list, "w") as fp:
             fp.write("# This file is used internally by FFMPEG.\n")
             for pf_path in partial_movie_files:

manim/utils/hashing.py

@@ -252,9 +252,11 @@ def get_hash_from_play_call(
     ]
     t_end = perf_counter()
     logger.debug("Hashing done in %(time)s s.", {"time": str(t_end - t_start)[:8]})
+    hash_complete = f"{hash_camera}_{hash_animations}_{hash_current_mobjects}"
     # This will reset ALREADY_PROCESSED_ID as all the hashing processus is finished.
     ALREADY_PROCESSED_ID = {}
-    return "{}_{}_{}".format(hash_camera, hash_animations, hash_current_mobjects)
+    logger.debug("Hash generated :  %(h)s", {"h": hash_complete})
+    return hash_complete
 
 
 def get_hash_from_wait_call(
@@ -299,15 +301,15 @@ def get_hash_from_wait_call(
         ALREADY_PROCESSED_ID = {}
         t_end = perf_counter()
         logger.debug("Hashing done in %(time)s s.", {"time": str(t_end - t_start)[:8]})
-        return "{}_{}{}_{}".format(
-            hash_camera,
-            str(wait_time).replace(".", "-"),
-            hash_function,
-            hash_current_mobjects,
-        )
+        hash_complete = f"{hash_camera}_{str(wait_time).replace('.', '-')}{hash_function}_{hash_current_mobjects}"
+        logger.debug("Hash generated :  %(h)s", {"h": hash_complete})
+        return hash_complete
     ALREADY_PROCESSED_ID = {}
     t_end = perf_counter()
     logger.debug("Hashing done in %(time)s s.", {"time": str(t_end - t_start)[:8]})
-    return "{}_{}_{}".format(
-        hash_camera, str(wait_time).replace(".", "-"), hash_current_mobjects
+    hash_complete = (
+        f"{hash_camera}_{str(wait_time).replace('.', '-')}_{hash_current_mobjects}"
     )
+
+    logger.debug("Hash generated :  %(h)s", {"h": hash_complete})
+    return hash_complete

tests/control_data/logs_data/BasicSceneLoggingTest.txt

@@ -1,6 +1,9 @@
 {"levelname": "INFO", "module": "config", "message": "Log file will be saved in <>"}
 {"levelname": "DEBUG", "module": "hashing", "message": "Hashing ..."}
 {"levelname": "DEBUG", "module": "hashing", "message": "Hashing done in <> s."}
+{"levelname": "DEBUG", "module": "hashing", "message": "Hash generated :  <>"}
+{"levelname": "DEBUG", "module": "cairo_renderer", "message": "List of the first few animation hashes of the scene: <>"}
 {"levelname": "INFO", "module": "scene_file_writer", "message": "Animation 0 : Partial movie file written in <>"}
+{"levelname": "DEBUG", "module": "scene_file_writer", "message": "Partial movie files to combine (1 files): <>"}
 {"levelname": "INFO", "module": "scene_file_writer", "message": "\nFile ready at <>\n"}
 {"levelname": "INFO", "module": "cairo_renderer", "message": "Rendered SquareToCircle\nPlayed 1 animations"}

tests/test_scene_rendering/test_caching_relalted.py renamed to tests/test_scene_rendering/test_caching_related.py

@@ -4,7 +4,7 @@
 from manim import file_writer_config
 
 from ..utils.commands import capture
-from ..utils.video_tester import video_comparison
+from ..utils.video_tester import *
 
 
 @video_comparison(
@@ -20,7 +20,7 @@ def test_wait_skip(tmp_path, manim_cfg_file, simple_scenes_path):
         "manim",
         simple_scenes_path,
         scene_name,
-        "-ql",
+        "-l",
         "--media_dir",
         str(tmp_path),
         "-n",
@@ -43,7 +43,7 @@ def test_play_skip(tmp_path, manim_cfg_file, simple_scenes_path):
         "manim",
         simple_scenes_path,
         scene_name,
-        "-ql",
+        "-l",
         "--media_dir",
         str(tmp_path),
         "-n",