Initialize CairoRenderer without a Scene

Author: eulertour

manim/renderer/cairo_renderer.py

@@ -55,7 +55,7 @@ class CairoRenderer:
     time: time elapsed since initialisation of scene.
     """
 
-    def __init__(self, scene, camera_class, **kwargs):
+    def __init__(self, camera_class, **kwargs):
         # All of the following are set to EITHER the value passed via kwargs,
         # OR the value stored in the global config dict at the time of
         # _instance construction_.  Before, they were in the CONFIG dict, which
@@ -72,16 +72,19 @@ def __init__(self, scene, camera_class, **kwargs):
         ]:
             self.video_quality_config[attr] = kwargs.get(attr, config[attr])
         self.camera = camera_class(self.video_quality_config, **camera_config)
-        self.file_writer = SceneFileWriter(
-            self.video_quality_config,
-            scene,
-            **file_writer_config,
-        )
         self.original_skipping_status = file_writer_config["skip_animations"]
         self.animations_hashes = []
         self.num_plays = 0
         self.time = 0
 
+    def init_file_writer(self, scene_name):
+        self.file_writer = SceneFileWriter(
+            self,
+            self.video_quality_config,
+            scene_name,
+            **file_writer_config,
+        )
+
     @manage_scene_reference
     @handle_caching_play
     @handle_play_like_call

manim/scene/scene.py

@@ -65,7 +65,8 @@ def construct(self):
 
     def __init__(self, **kwargs):
         Container.__init__(self, **kwargs)
-        self.renderer = CairoRenderer(self, self.camera_class)
+        self.renderer = CairoRenderer(self.camera_class)
+        self.renderer.init_file_writer(self.__class__.__name__)
 
         self.mobjects = []
         # TODO, remove need for foreground mobjects

manim/scene/scene_file_writer.py

@@ -42,25 +42,25 @@ class SceneFileWriter(object):
 
     """
 
-    def __init__(self, video_quality_config, scene, **kwargs):
+    def __init__(self, renderer, video_quality_config, scene_name, **kwargs):
         digest_config(self, kwargs)
+        self.renderer = renderer
         self.video_quality_config = video_quality_config
-        self.scene = scene
         self.stream_lock = False
-        self.init_output_directories()
+        self.init_output_directories(scene_name)
         self.init_audio()
         self.frame_count = 0
         self.partial_movie_files = []
 
     # Output directories and files
-    def init_output_directories(self):
+    def init_output_directories(self, scene_name):
         """
         This method initialises the directories to which video
         files will be written to and read from (within MEDIA_DIR).
         If they don't already exist, they will be created.
         """
         module_directory = self.get_default_module_directory()
-        scene_name = self.get_default_scene_name()
+        default_name = self.get_default_scene_name(scene_name)
         if file_writer_config["save_last_frame"] or file_writer_config["save_pngs"]:
             if file_writer_config["media_dir"] != "":
                 if not file_writer_config["custom_folders"]:
@@ -73,7 +73,7 @@ def init_output_directories(self):
                 else:
                     image_dir = guarantee_existence(file_writer_config["images_dir"])
             self.image_file_path = os.path.join(
-                image_dir, add_extension_if_not_present(scene_name, ".png")
+                image_dir, add_extension_if_not_present(default_name, ".png")
             )
 
         if file_writer_config["write_to_movie"]:
@@ -93,18 +93,19 @@ def init_output_directories(self):
             self.movie_file_path = os.path.join(
                 movie_dir,
                 add_extension_if_not_present(
-                    scene_name, file_writer_config["movie_file_extension"]
+                    default_name, file_writer_config["movie_file_extension"]
                 ),
             )
             self.gif_file_path = os.path.join(
-                movie_dir, add_extension_if_not_present(scene_name, GIF_FILE_EXTENSION)
+                movie_dir,
+                add_extension_if_not_present(default_name, GIF_FILE_EXTENSION),
             )
             if not file_writer_config["custom_folders"]:
                 self.partial_movie_directory = guarantee_existence(
                     os.path.join(
                         movie_dir,
                         "partial_movie_files",
-                        scene_name,
+                        default_name,
                     )
                 )
             else:
@@ -113,7 +114,7 @@ def init_output_directories(self):
                         file_writer_config["media_dir"],
                         "temp_files",
                         "partial_movie_files",
-                        scene_name,
+                        default_name,
                     )
                 )
 
@@ -154,7 +155,7 @@ def get_default_module_directory(self):
         root, _ = os.path.splitext(filename)
         return root
 
-    def get_default_scene_name(self):
+    def get_default_scene_name(self, scene_name):
         """
         This method returns the default scene name
         which is the value of "output_file", if it exists and
@@ -167,7 +168,7 @@ def get_default_scene_name(self):
             The default scene name.
         """
         fn = file_writer_config["output_file"]
-        return fn if fn else self.scene.__class__.__name__
+        return fn if fn else scene_name
 
     def get_resolution_directory(self):
         """Get the name of the resolution directory directly containing
@@ -400,7 +401,7 @@ def open_movie_pipe(self):
         FFMPEG and begin writing to FFMPEG's input
         buffer.
         """
-        file_path = self.partial_movie_files[self.scene.renderer.num_plays]
+        file_path = self.partial_movie_files[self.renderer.num_plays]
 
         # TODO #486 Why does ffmpeg need temp files ?
         temp_file_path = (
@@ -464,7 +465,7 @@ def close_movie_pipe(self):
             self.partial_movie_file_path,
         )
         logger.info(
-            f"Animation {self.scene.renderer.num_plays} : Partial movie file written in %(path)s",
+            f"Animation {self.renderer.num_plays} : Partial movie file written in %(path)s",
             {"path": {self.partial_movie_file_path}},
         )
 

tests/test_renderer.py

@@ -6,22 +6,19 @@ def test_renderer():
     """Test that CairoRenderer instances initialize to the correct config."""
     # by default, use the config
     assert (
-        CairoRenderer(None, Camera).video_quality_config["frame_width"]
+        CairoRenderer(Camera).video_quality_config["frame_width"]
         == config["frame_width"]
     )
     # init args override config
     assert (
-        CairoRenderer(None, Camera, frame_width=10).video_quality_config["frame_width"]
-        == 10
+        CairoRenderer(Camera, frame_width=10).video_quality_config["frame_width"] == 10
     )
 
     # if config changes, reflect those changes
     with tempconfig({"frame_width": 100}):
-        assert CairoRenderer(None, Camera).video_quality_config["frame_width"] == 100
+        assert CairoRenderer(Camera).video_quality_config["frame_width"] == 100
         # ..init args still override new config
         assert (
-            CairoRenderer(None, Camera, frame_width=10).video_quality_config[
-                "frame_width"
-            ]
+            CairoRenderer(Camera, frame_width=10).video_quality_config["frame_width"]
             == 10
         )