def main():
args = parse_args(sys.argv)
if hasattr(args, "cmd"):
if args.cmd == "cfg":
if args.subcmd:
from manim._config import cfg_subcmds
if args.subcmd == "write":
cfg_subcmds.write(args.level, args.open)
elif args.subcmd == "show":
cfg_subcmds.show()
elif args.subcmd == "export":
cfg_subcmds.export(args.dir)
else:
logger.error("No subcommand provided; Exiting...")
elif args.cmd == "plugins":
from manim.plugins import plugins_flags
if args.list:
plugins_flags.list_plugins()
elif not args.list:
logger.error("No flag provided; Exiting...")
# elif args.cmd == "some_other_cmd":
# something_else_here()
else:
config.digest_args(args)
module = get_module(config.get_dir("input_file"))
all_scene_classes = get_scene_classes_from_module(module)
scene_classes_to_render = get_scenes_to_render(all_scene_classes)
for SceneClass in scene_classes_to_render:
try:
if config["use_js_renderer"]:
if frame_server_impl is None:
raise ImportError(
"Dependencies for JS renderer is not installed.")
frame_server_impl.get(SceneClass).start()
else:
scene = SceneClass()
scene.render()
open_file_if_needed(scene.renderer.file_writer)
except Exception:
print("\n\n")
traceback.print_exc()
print("\n\n")
def main():
console.print(f"Manim Community [green]v{__version__}[/green]")
args = parse_args(sys.argv)
if hasattr(args, "cmd"):
if args.cmd == "cfg":
if args.subcmd:
from manim._config import cfg_subcmds
if args.subcmd == "write":
cfg_subcmds.write(args.level, args.open)
elif args.subcmd == "show":
cfg_subcmds.show()
elif args.subcmd == "export":
cfg_subcmds.export(args.dir)
else:
logger.error("No subcommand provided; Exiting...")
elif args.cmd == "plugins":
from manim.plugins import plugins_flags
if args.list:
plugins_flags.list_plugins()
elif not args.list:
logger.error("No flag provided; Exiting...")
# elif args.cmd == "some_other_cmd":
# something_else_here()
else:
config.digest_args(args)
input_file = config.get_dir("input_file")
if config["use_webgl_renderer"]:
try:
from manim.grpc.impl import frame_server_impl
server = frame_server_impl.get(input_file)
server.start()
server.wait_for_termination()
except ModuleNotFoundError as e:
print("\n\n")
print("Dependencies for the WebGL render are missing. Run "
"pip install manim[webgl_renderer] to install them.")
print(e)
print("\n\n")
else:
for SceneClass in scene_classes_from_file(input_file):
try:
scene = SceneClass()
scene.render()
open_file_if_needed(scene.renderer.file_writer)
except Exception:
print("\n\n")
traceback.print_exc()
print("\n\n")
def main():
args = parse_args(sys.argv)
if hasattr(args, "cmd"):
if args.cmd == "cfg":
if args.subcmd:
from manim.config import cfg_subcmds
if args.subcmd == "write":
cfg_subcmds.write(args.level, args.open)
elif args.subcmd == "show":
cfg_subcmds.show()
elif args.subcmd == "export":
cfg_subcmds.export(args.dir)
else:
logger.error("No subcommand provided; Exiting...")
# elif args.cmd == "some_other_cmd":
# something_else_here()
else:
update_config_with_cli(args)
init_dirs(file_writer_config)
if file_writer_config["log_to_file"]:
set_file_logger()
module = get_module(file_writer_config["input_file"])
all_scene_classes = get_scene_classes_from_module(module)
scene_classes_to_render = get_scenes_to_render(all_scene_classes)
for SceneClass in scene_classes_to_render:
try:
if config["use_js_renderer"]:
frame_server_impl.get(SceneClass).start()
else:
scene = SceneClass()
scene.render()
open_file_if_needed(scene.renderer.file_writer)
except Exception:
print("\n\n")
traceback.print_exc()
print("\n\n")
def render(**args, ):
"""Render SCENE(S) from the input FILE.
FILE is the file path of the script or a config file.
SCENES is an optional list of scenes in the file.
"""
if args["use_opengl_renderer"]:
logger.warning(
"--use_opengl_renderer is deprecated, please use --renderer=opengl instead!",
)
args["renderer"] = "opengl"
if args["use_webgl_renderer"]:
logger.warning(
"--use_webgl_renderer is deprecated, please use --renderer=webgl instead!",
)
args["renderer"] = "webgl"
if args["use_webgl_renderer"] and args["use_opengl_renderer"]:
logger.warning("You may select only one renderer!")
sys.exit()
if args["save_as_gif"]:
logger.warning(
"--save_as_gif is deprecated, please use --format=gif instead!")
args["format"] = "gif"
if args["save_pngs"]:
logger.warning(
"--save_pngs is deprecated, please use --format=png instead!")
args["format"] = "png"
if args["show_in_file_browser"]:
logger.warning(
"The short form of show_in_file_browser is deprecated and will be moved to support --format.",
)
class ClickArgs:
def __init__(self, args):
for name in args:
setattr(self, name, args[name])
def _get_kwargs(self):
return list(self.__dict__.items())
def __eq__(self, other):
if not isinstance(other, ClickArgs):
return NotImplemented
return vars(self) == vars(other)
def __contains__(self, key):
return key in self.__dict__
def __repr__(self):
return str(self.__dict__)
click_args = ClickArgs(args)
if args["jupyter"]:
return click_args
config.digest_args(click_args)
file = Path(config.input_file)
if config.renderer == "opengl":
from manim.renderer.opengl_renderer import OpenGLRenderer
try:
renderer = OpenGLRenderer()
keep_running = True
while keep_running:
for SceneClass in scene_classes_from_file(file):
scene = SceneClass(renderer)
rerun = scene.render()
if rerun or config["write_all"]:
renderer.num_plays = 0
continue
else:
keep_running = False
break
if config["write_all"]:
keep_running = False
except Exception:
error_console.print_exception()
sys.exit(1)
elif config.renderer == "webgl":
try:
from manim.grpc.impl import frame_server_impl
server = frame_server_impl.get(file)
server.start()
server.wait_for_termination()
except ModuleNotFoundError:
console.print(
"Dependencies for the WebGL render are missing. Run "
"pip install manim[webgl_renderer] to install them.", )
error_console.print_exception()
sys.exit(1)
else:
for SceneClass in scene_classes_from_file(file):
try:
scene = SceneClass()
scene.render()
except Exception:
error_console.print_exception()
sys.exit(1)
if config.notify_outdated_version:
manim_info_url = "https://pypi.org/pypi/manim/json"
warn_prompt = "Cannot check if latest release of manim is installed"
req_info = {}
try:
req_info = requests.get(manim_info_url)
req_info.raise_for_status()
stable = req_info.json()["info"]["version"]
if stable != __version__:
console.print(
f"You are using manim version [red]v{__version__}[/red], but version [green]v{stable}[/green] is available.",
)
console.print(
"You should consider upgrading via [yellow]pip install -U manim[/yellow]",
)
except requests.exceptions.HTTPError:
logger.debug(f"HTTP Error: {warn_prompt}")
except requests.exceptions.ConnectionError:
logger.debug(f"Connection Error: {warn_prompt}")
except requests.exceptions.Timeout:
logger.debug(f"Timed Out: {warn_prompt}")
except json.JSONDecodeError:
logger.debug(warn_prompt)
logger.debug(f"Error decoding JSON from {manim_info_url}")
except Exception:
logger.debug(f"Something went wrong: {warn_prompt}")
return args
def render(
ctx,
**args,
):
"""Render SCENE(S) from the input FILE.
FILE is the file path of the script.
SCENES is an optional list of scenes in the file.
"""
for scene in args["scene_names"]:
if str(scene).startswith("-"):
logger.warning(
dedent(
"""\
Manim Community has moved to Click for the CLI.
This means that options in the CLI are provided BEFORE the positional
arguments for your FILE and SCENE(s):
`manim render [OPTIONS] [FILE] [SCENES]...`
For example:
New way - `manim -p -ql file.py SceneName1 SceneName2 ...`
Old way - `manim file.py SceneName1 SceneName2 ... -p -ql`
To see the help page for the new available options, run:
`manim render -h`
"""
)
)
sys.exit()
if args["use_opengl_renderer"]:
logger.warning(
"--use_opengl_renderer is deprecated, please use --renderer=opengl instead!"
)
renderer = "opengl"
if args["use_webgl_renderer"]:
logger.warning(
"--use_webgl_renderer is deprecated, please use --renderer=webgl instead!"
)
renderer = "webgl"
if args["use_webgl_renderer"] and args["use_opengl_renderer"]:
logger.warning("You may select only one renderer!")
sys.exit()
class ClickArgs:
def __init__(self, args):
for name in args:
setattr(self, name, args[name])
def _get_kwargs(self):
return list(self.__dict__.items())
def __eq__(self, other):
if not isinstance(other, ClickArgs):
return NotImplemented
return vars(self) == vars(other)
def __contains__(self, key):
return key in self.__dict__
def __repr__(self):
return str(self.__dict__)
click_args = ClickArgs(args)
if args["jupyter"]:
return click_args
config.digest_args(click_args)
file = args["file"]
if config.renderer == "opengl":
from manim.renderer.opengl_renderer import OpenGLRenderer
for SceneClass in scene_classes_from_file(file):
try:
renderer = OpenGLRenderer()
scene = SceneClass(renderer)
scene.render()
except Exception:
console.print_exception()
elif config.renderer == "webgl":
try:
from manim.grpc.impl import frame_server_impl
server = frame_server_impl.get(file)
server.start()
server.wait_for_termination()
except ModuleNotFoundError:
console.print(
"Dependencies for the WebGL render are missing. Run "
"pip install manim[webgl_renderer] to install them."
)
console.print_exception()
else:
for SceneClass in scene_classes_from_file(file):
try:
scene = SceneClass()
scene.render()
except Exception:
console.print_exception()
if config.notify_outdated_version:
manim_info_url = "https://pypi.org/pypi/manim/json"
warn_prompt = "Cannot check if latest release of manim is installed"
req_info = {}
try:
req_info = requests.get(manim_info_url)
req_info.raise_for_status()
except requests.exceptions.HTTPError:
logger.debug(f"HTTP Error: {warn_prompt}")
except requests.exceptions.ConnectionError:
logger.debug(f"Connection Error: {warn_prompt}")
except requests.exceptions.Timeout:
logger.debug(f"Timed Out: {warn_prompt}")
except Exception:
logger.debug(f"Something went wrong: {warn_prompt}")
try:
stable = req_info.json()["info"]["version"]
if stable != __version__:
console.print(
f"You are using manim version [red]v{__version__}[/red], but version [green]v{stable}[/green] is available."
)
console.print(
"You should consider upgrading via [yellow]pip install -U manim[/yellow]"
)
except json.JSONDecodeError:
logger.debug(warn_prompt)
logger.debug(f"Error decoding JSON from {manim_info_url}")
return args
def render(
ctx,
**args,
):
"""Render SCENE(S) from the input FILE.
FILE is the file path of the script.
SCENES is an optional list of scenes in the file.
"""
for scene in args["scene_names"]:
if str(scene).startswith("-"):
logger.warning(
dedent("""\
Manim Community has moved to Click for the CLI.
This means that options in the CLI are provided BEFORE the positional
arguments for your FILE and SCENE(s):
`manim render [OPTIONS] [FILE] [SCENES]...`
For example:
New way - `manim -p -ql file.py SceneName1 SceneName2 ...`
Old way - `manim file.py SceneName1 SceneName2 ... -p -ql`
To see the help page for the new available options, run:
`manim render -h`
"""))
sys.exit()
if args["use_opengl_renderer"]:
logger.warning(
"--use_opengl_renderer is deprecated, please use --renderer=opengl instead!"
)
renderer = "opengl"
if args["use_webgl_renderer"]:
logger.warning(
"--use_webgl_renderer is deprecated, please use --renderer=webgl instead!"
)
renderer = "webgl"
if args["use_webgl_renderer"] and args["use_opengl_renderer"]:
logger.warning("You may select only one renderer!")
sys.exit()
class ClickArgs:
def __init__(self, args):
for name in args:
setattr(self, name, args[name])
def _get_kwargs(self):
return list(self.__dict__.items())
def __eq__(self, other):
if not isinstance(other, ClickArgs):
return NotImplemented
return vars(self) == vars(other)
def __contains__(self, key):
return key in self.__dict__
def __repr__(self):
return str(self.__dict__)
click_args = ClickArgs(args)
if args["jupyter"]:
return click_args
config.digest_args(click_args)
file = args["file"]
if config.renderer == "opengl":
from manim.renderer.opengl_renderer import OpenGLRenderer
for SceneClass in scene_classes_from_file(file):
try:
renderer = OpenGLRenderer()
scene = SceneClass(renderer)
scene.render()
except Exception:
console.print_exception()
elif config.renderer == "webgl":
try:
from manim.grpc.impl import frame_server_impl
server = frame_server_impl.get(file)
server.start()
server.wait_for_termination()
except ModuleNotFoundError:
console.print("Dependencies for the WebGL render are missing. Run "
"pip install manim[webgl_renderer] to install them.")
console.print_exception()
else:
for SceneClass in scene_classes_from_file(file):
try:
scene = SceneClass()
scene.render()
except Exception:
console.print_exception()
return args