mirror of
https://github.com/3b1b/manim.git
synced 2025-04-13 09:47:07 +00:00
94f6f0aa96
* Remove print("Reloading...")
* Change where exception mode is set, to be quieter
* Add default fallback monitor for when no monitors are detected
* Have StringMobject work with svg strings rather than necessarily writing to file
Change SVGMobject to allow taking in a string of svg code as an input
* Add caching functionality, and have Tex and Text both use it for saved svg strings
* Clean up tex_file_writing
* Get rid of get_tex_dir and get_text_dir
* Allow for a configurable cache location
* Make caching on disk a decorator, and update implementations for Tex and Text mobjects
* Remove stray prints
* Clean up how configuration is handled
In principle, all we need here is that manim looks to the default_config.yaml file, and updates it based on any local configuration files, whether in the current working directory or as specified by a CLI argument.
* Make the default size for hash_string an option
* Remove utils/customization.py
* Remove stray prints
* Consolidate camera configuration
This is still not optimal, but at least makes clearer the way that importing from constants.py kicks off some of the configuration code.
* Factor out configuration to be passed into a scene vs. that used to run a scene
* Use newer extract_scene.main interface
* Add clarifying message to note what exactly is being reloaded
* Minor clean up
* Minor clean up
* If it's worth caching to disk, then might as well do so in memory too during development
* No longer any need for custom hash_seeds in Tex and Text
* Remove display_during_execution
* Get rid of (no longer used) mobject_data directory reference
* Remove get_downloads_dir reference from register_font
* Update where downloads go
* Easier use of subdirectories in configuration
* Add new pip requirements
90 lines
2.9 KiB
Python
90 lines
2.9 KiB
Python
from typing import Any
|
|
from IPython.terminal.embed import KillEmbedded
|
|
|
|
|
|
class ReloadManager:
|
|
"""
|
|
Manages the loading and running of scenes and is called directly from the
|
|
main entry point of ManimGL.
|
|
|
|
The name "reload" comes from the fact that this class handles the
|
|
reinitialization of scenes when requested by the user via the `reload()`
|
|
command in the IPython shell.
|
|
"""
|
|
|
|
args: Any = None
|
|
scenes: list[Any] = []
|
|
window = None
|
|
|
|
# The line number to load the scene from when reloading
|
|
start_at_line = None
|
|
|
|
def set_new_start_at_line(self, start_at_line):
|
|
"""
|
|
Sets/Updates the line number to load the scene from when reloading.
|
|
"""
|
|
self.start_at_line = start_at_line
|
|
|
|
def run(self):
|
|
"""
|
|
Runs the scenes in a loop and detects when a scene reload is requested.
|
|
"""
|
|
while True:
|
|
try:
|
|
# blocking call since a scene will init an IPython shell()
|
|
self.retrieve_scenes_and_run(self.start_at_line)
|
|
return
|
|
except KillEmbedded:
|
|
# Requested via the `exit_raise` IPython runline magic
|
|
# by means of our scene.reload() command
|
|
for scene in self.scenes:
|
|
scene.tear_down()
|
|
|
|
self.scenes = []
|
|
|
|
except KeyboardInterrupt:
|
|
break
|
|
|
|
def retrieve_scenes_and_run(self, overwrite_start_at_line: int | None = None):
|
|
"""
|
|
Creates a new configuration based on the CLI args and runs the scenes.
|
|
"""
|
|
import manimlib.config
|
|
import manimlib.extract_scene
|
|
|
|
# Args
|
|
if self.args is None:
|
|
raise RuntimeError("Fatal error: No args were passed to the ReloadManager")
|
|
if overwrite_start_at_line is not None:
|
|
self.args.embed = str(overwrite_start_at_line)
|
|
|
|
# Args to Config
|
|
scene_config = manimlib.config.get_scene_config(self.args)
|
|
if self.window:
|
|
scene_config["existing_window"] = self.window # see scene initialization
|
|
|
|
run_config = manimlib.config.get_run_config(self.args)
|
|
|
|
# Scenes
|
|
self.scenes = manimlib.extract_scene.main(scene_config, run_config)
|
|
if len(self.scenes) == 0:
|
|
print("No scenes found to run")
|
|
return
|
|
|
|
# Find first available window
|
|
for scene in self.scenes:
|
|
if scene.window is not None:
|
|
self.window = scene.window
|
|
break
|
|
|
|
for scene in self.scenes:
|
|
if self.args.embed:
|
|
print(" ".join([
|
|
"Loading interactive session for",
|
|
f"\033[96m{self.args.scene_names[0]}\033[0m",
|
|
f"in \033[96m{self.args.file}\033[0m",
|
|
f"at line \033[96m{self.args.embed}\033[0m"
|
|
]))
|
|
scene.run()
|
|
|
|
reload_manager = ReloadManager()
|