Merge pull request #543 from ManimCommunity/refactor-config-subpkg

Refactor config subpkg

Author: leotrs

manim/__main__.py

@@ -3,16 +3,16 @@
 import sys
 import traceback
 
-from . import logger, file_writer_config
-from .config.config import camera_config, args
-from .config import cfg_subcmds
-from .utils.module_ops import (
+from manim import constants, logger, console, config, file_writer_config
+from manim import Scene
+from manim.utils.module_ops import (
     get_module,
     get_scene_classes_from_module,
     get_scenes_to_render,
 )
-from .utils.file_ops import open_file as open_media_file
-from .grpc.impl import frame_server_impl
+from manim.utils.file_ops import open_file as open_media_file
+from manim.grpc.impl import frame_server_impl
+from manim.config.main_utils import *
 
 
 def open_file_if_needed(file_writer):
@@ -49,26 +49,38 @@ def open_file_if_needed(file_writer):
 
 
 def main():
-    if hasattr(args, "subcommands"):
-        if "cfg" in args.subcommands:
-            if args.cfg_subcommand is not None:
-                subcommand = args.cfg_subcommand
-                if subcommand == "write":
+    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 subcommand == "show":
+                elif args.subcmd == "show":
                     cfg_subcmds.show()
-                elif subcommand == "export":
+                elif args.subcmd == "export":
                     cfg_subcmds.export(args.dir)
             else:
-                logger.error("No argument provided; Exiting...")
+                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 camera_config["use_js_renderer"]:
+                if config["use_js_renderer"]:
                     frame_server_impl.get(SceneClass).start()
                 else:
                     scene = SceneClass()

manim/config/__init__.py

@@ -1,16 +1,73 @@
-# Note that the global config dict is called 'config', just like the module
-# itself.  That's why we import the module first with a different name
-# (_config), and then the dict.
-from . import config as _config
-from .config import config, tempconfig, file_writer_config, camera_config
-from .logger import logger, console
+import logging
+from contextlib import contextmanager
+
+from .utils import make_config_parser, make_logger, make_config, make_file_writer_config
 
 __all__ = [
-    "_config",
+    "logger",
+    "console",
     "config",
-    "tempconfig",
     "file_writer_config",
     "camera_config",
-    "logger",
-    "console",
+    "tempconfig",
 ]
+
+parser = make_config_parser()
+
+# The logger can be accessed from anywhere as manim.logger, or as
+# logging.getLogger("manim").  The console must be accessed as manim.console.
+# Throughout the codebase, use manim.console.print() instead of print().
+logger, console = make_logger(parser["logger"], parser["CLI"]["verbosity"])
+# TODO: temporary to have a clean terminal output when working with PIL or matplotlib
+logging.getLogger("PIL").setLevel(logging.INFO)
+logging.getLogger("matplotlib").setLevel(logging.INFO)
+
+config = make_config(parser)
+camera_config = config
+file_writer_config = make_file_writer_config(parser, config)
+
+
+# This has to go here because it needs access to this module's config
+@contextmanager
+def tempconfig(temp):
+    """Context manager that temporarily modifies the global config dict.
+
+    The code block inside the ``with`` statement will use the modified config.
+    After the code block, the config will be restored to its original value.
+
+    Parameters
+    ----------
+
+    temp : :class:`dict`
+        A dictionary whose keys will be used to temporarily update the global
+        config.
+
+    Examples
+    --------
+    Use ``with tempconfig({...})`` to temporarily change the default values of
+    certain objects.
+
+    .. code_block:: python
+
+       c = Camera()
+       c.frame_width == config['frame_width']        # -> True
+       with tempconfig({'frame_width': 100}):
+           c = Camera()
+           c.frame_width == config['frame_width']    # -> False
+           c.frame_width == 100                      # -> True
+
+    """
+    global config
+    original = config.copy()
+
+    temp = {k: v for k, v in temp.items() if k in original}
+
+    # In order to change the config that every module has acces to, use
+    # update(), DO NOT use assignment.  Assigning config = some_dict will just
+    # make the local variable named config point to a new dictionary, it will
+    # NOT change the dictionary that every module has a reference to.
+    config.update(temp)
+    try:
+        yield
+    finally:
+        config.update(original)  # update, not assignment!

manim/config/cfg_subcmds.py

@@ -6,24 +6,22 @@
 The functions below can be called via the `manim cfg` subcommand.
 
 """
+
 import os
-import configparser
 from ast import literal_eval
 
-from .config_utils import _run_config, _paths_config_file, finalized_configs_dict
-from ..utils.file_ops import guarantee_existence, open_file
-
-from rich.console import Console
-from rich.style import Style
-from rich.errors import StyleSyntaxError
+from manim import logger, console, config
+from manim.config.utils import config_file_paths, make_config_parser
+from manim.utils.file_ops import guarantee_existence, open_file
 
 __all__ = ["write", "show", "export"]
 
-RICH_COLOUR_INSTRUCTIONS = """[red]The default colour is used by the input statement.
+RICH_COLOUR_INSTRUCTIONS = """
+[red]The default colour is used by the input statement.
 If left empty, the default colour will be used.[/red]
-[magenta] For a full list of styles, visit[/magenta] [green]https://rich.readthedocs.io/en/latest/style.html[/green]"""
+[magenta] For a full list of styles, visit[/magenta] [green]https://rich.readthedocs.io/en/latest/style.html[/green]
+"""
 RICH_NON_STYLE_ENTRIES = ["log.width", "log.height", "log.timestamps"]
-console = Console()
 
 
 def value_from_string(value):
@@ -114,8 +112,7 @@ def replace_keys(default):
 
 
 def write(level=None, openfile=False):
-    config = _run_config()[1]
-    config_paths = _paths_config_file() + [os.path.abspath("manim.cfg")]
+    config_paths = config_file_paths()
     console.print(
         "[yellow bold]Manim Configuration File Writer[/yellow bold]", justify="center"
     )
@@ -127,11 +124,12 @@ def write(level=None, openfile=False):
     CWD_CONFIG_MSG = f"""A configuration file at [yellow]{config_paths[2]}[/yellow] has been created.
 To save your config please save that file and place it in your current working directory, from where you run the manim command."""
 
+    parser = make_config_parser()
     if not openfile:
         action = "save this as"
-        for category in config:
+        for category in parser:
             console.print(f"{category}", style="bold green underline")
-            default = config[category]
+            default = parser[category]
             if category == "logger":
                 console.print(RICH_COLOUR_INSTRUCTIONS)
                 default = replace_keys(default)
@@ -178,7 +176,7 @@ def write(level=None, openfile=False):
 
             default = replace_keys(default) if category == "logger" else default
 
-            config[category] = dict(default)
+            parser[category] = dict(default)
 
     else:
         action = "open"
@@ -194,40 +192,37 @@ def write(level=None, openfile=False):
         action_to_userpath = ""
 
     if action_to_userpath.lower() == "y" or level == "user":
-        cfg_file_path = os.path.join(
-            guarantee_existence(os.path.dirname(config_paths[1])), "manim.cfg"
-        )
+        cfg_file_path = config_paths[1]
+        guarantee_existence(config_paths[1].parents[0])
         console.print(USER_CONFIG_MSG)
     else:
-        cfg_file_path = os.path.join(
-            guarantee_existence(os.path.dirname(config_paths[2])), "manim.cfg"
-        )
+        cfg_file_path = config_paths[2]
+        guarantee_existence(config_paths[2].parents[0])
         console.print(CWD_CONFIG_MSG)
     with open(cfg_file_path, "w") as fp:
-        config.write(fp)
+        parser.write(fp)
     if openfile:
         open_file(cfg_file_path)
 
 
 def show():
-    current_config = finalized_configs_dict()
+    parser = make_config_parser()
     rich_non_style_entries = [a.replace(".", "_") for a in RICH_NON_STYLE_ENTRIES]
-    for category in current_config:
+    for category in parser:
         console.print(f"{category}", style="bold green underline")
-        for entry in current_config[category]:
+        for entry in parser[category]:
             if category == "logger" and entry not in rich_non_style_entries:
                 console.print(f"{entry} :", end="")
                 console.print(
-                    f" {current_config[category][entry]}",
-                    style=current_config[category][entry],
+                    f" {parser[category][entry]}",
+                    style=parser[category][entry],
                 )
             else:
-                console.print(f"{entry} : {current_config[category][entry]}")
+                console.print(f"{entry} : {parser[category][entry]}")
         console.print("\n")
 
 
 def export(path):
-    config = _run_config()[1]
     if os.path.abspath(path) == os.path.abspath(os.getcwd()):
         console.print(
             """You are reading the config from the same directory you are exporting to.