Merge branch 'refactor-tests' of https://github.com/Darylgolden/manim into refactor-tests

Author: Darylgolden

.github/workflows/ci.yml

@@ -45,7 +45,7 @@ jobs:
 
       - name: Install Manim
         run: |
-          poetry install -E webgl_renderer
+          poetry install
 
       - name: Run tests
         run: |
@@ -202,7 +202,7 @@ jobs:
       - name: Install manim
         run: |
           poetry config experimental.new-installer false
-          poetry install -E webgl_renderer
+          poetry install
 
       - name: Run tests
         run: |

.pre-commit-config.yaml

@@ -56,7 +56,7 @@ repos:
                                   flake8-docstrings==1.6.0, flake8-rst-docstrings==0.2.3,
                                   flake8-pytest-style==1.5.0, flake8-simplify==0.14.1, flake8-comprehensions>=3.6.1]
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: 'v0.941'
+    rev: 'v0.942'
     hooks:
       - id: mypy
         additional_dependencies: [types-decorator, types-docutils, types-requests, types-setuptools]

docker/Dockerfile

@@ -30,7 +30,7 @@ RUN wget -O /tmp/install-tl-unx.tar.gz http://mirror.ctan.org/systems/texlive/tl
 # clone and build manim
 COPY . /opt/manim
 WORKDIR /opt/manim
-RUN pip install --no-cache .[jupyterlab,webgl_renderer]
+RUN pip install --no-cache .[jupyterlab]
 
 RUN pip install -r docs/requirements.txt
 

docs/source/tutorials/configuration.rst

@@ -360,7 +360,6 @@ A list of all config options
    'progress_bar', 'quality', 'right_side', 'save_as_gif', 'save_last_frame',
    'save_pngs', 'scene_names', 'show_in_file_browser', 'sound', 'tex_dir',
    'tex_template', 'tex_template_file', 'text_dir', 'top', 'transparent',
-   'upto_animation_number', 'use_opengl_renderer', 'use_webgl_renderer',
-   'verbosity', 'video_dir', 'webgl_renderer_path', 'window_position',
-   'window_monitor', 'window_size', 'write_all', 'write_to_movie', 'enable_wireframe',
-   'force_window']
+   'upto_animation_number', 'use_opengl_renderer', 'verbosity', 'video_dir',
+   'window_position', 'window_monitor', 'window_size', 'write_all', 'write_to_movie',
+   'enable_wireframe', 'force_window']

manim/__init__.py

@@ -27,8 +27,6 @@
         config.renderer = parsed_renderer
     elif arg == "--use_opengl_renderer":
         config.renderer = "opengl"
-    elif arg == "--use_webgl_renderer":
-        config.renderer = "webgl"
 
 # many scripts depend on this -> has to be loaded first
 from .utils.commands import *  # isort:skip

manim/_config/default.cfg

@@ -93,15 +93,9 @@ tex_dir = {media_dir}/Tex
 text_dir = {media_dir}/texts
 partial_movie_dir = {video_dir}/partial_movie_files/{scene_name}
 
-# --renderer [cairo|opengl|webgl]
+# --renderer [cairo|opengl]
 renderer = cairo
 
-# --use_webgl_renderer
-use_webgl_renderer = False
-
-# --webgl_renderer_path
-webgl_renderer_path =
-
 # --use_opengl_renderer
 use_opengl_renderer = False
 

manim/_config/logger_utils.py

@@ -15,7 +15,6 @@
 import copy
 import json
 import logging
-import os
 import sys
 from typing import TYPE_CHECKING
 
@@ -26,7 +25,7 @@
 from rich.theme import Theme
 
 if TYPE_CHECKING:
-    from manim._config.utils import ManimConfig
+    from pathlib import Path
 HIGHLIGHTED_KEYWORDS = [  # these keywords are highlighted specially
     "Played",
     "animations",
@@ -142,7 +141,7 @@ def parse_theme(parser: configparser.ConfigParser) -> Theme:
     return custom_theme
 
 
-def set_file_logger(config: ManimConfig, verbosity: str) -> None:
+def set_file_logger(scene_name: str, module_name: str, log_dir: Path) -> None:
     """Add a file handler to manim logger.
 
     The path to the file is built using ``config.log_dir``.
@@ -152,28 +151,13 @@ def set_file_logger(config: ManimConfig, verbosity: str) -> None:
     config : :class:`ManimConfig`
         The global config, used to determine the log file path.
 
-    verbosity : :class:`str`
-        The verbosity level of the logger.
-
-    Notes
-    -----
-    Calling this function changes the verbosity of all handlers assigned to
-    manim logger.
-
     """
     # Note: The log file name will be
     # <name_of_animation_file>_<name_of_scene>.log, gotten from config.  So it
     # can differ from the real name of the scene.  <name_of_scene> would only
     # appear if scene name was provided when manim was called.
-    scene_name_suffix = "".join(config["scene_names"])
-    scene_file_name = os.path.basename(config["input_file"]).split(".")[0]
-    log_file_name = (
-        f"{scene_file_name}_{scene_name_suffix}.log"
-        if scene_name_suffix
-        else f"{scene_file_name}.log"
-    )
-    log_file_path = config.get_dir("log_dir") / log_file_name
-    log_file_path.parent.mkdir(parents=True, exist_ok=True)
+    log_file_name = f"{module_name}_{scene_name}.log"
+    log_file_path = log_dir / log_file_name
 
     file_handler = logging.FileHandler(log_file_path, mode="w")
     file_handler.setFormatter(JSONFormatter())
@@ -182,9 +166,6 @@ def set_file_logger(config: ManimConfig, verbosity: str) -> None:
     logger.addHandler(file_handler)
     logger.info("Log file will be saved in %(logpath)s", {"logpath": log_file_path})
 
-    config.verbosity = verbosity
-    logger.setLevel(verbosity)
-
 
 class JSONFormatter(logging.Formatter):
     """A formatter that outputs logs in a custom JSON format.

manim/_config/utils.py

@@ -19,17 +19,16 @@
 import os
 import re
 import sys
-import typing
 from collections.abc import Mapping, MutableMapping
 from pathlib import Path
+from typing import Any, Iterable, Iterator
 
 import colour
 import numpy as np
 
 from .. import constants
 from ..utils.tex import TexTemplate, TexTemplateFromFile
 from ..utils.tex_templates import TexTemplateLibrary
-from .logger_utils import set_file_logger
 
 
 def config_file_paths() -> list[Path]:
@@ -255,7 +254,6 @@ class MyScene(Scene):
         "input_file",
         "media_embed",
         "media_width",
-        "webgl_renderer_path",
         "log_dir",
         "log_to_file",
         "max_files_cached",
@@ -282,7 +280,6 @@ class MyScene(Scene):
         "upto_animation_number",
         "renderer",
         "use_opengl_renderer",
-        "use_webgl_renderer",
         "enable_gui",
         "gui_location",
         "use_projection_fill_shaders",
@@ -304,7 +301,7 @@ def __init__(self) -> None:
         self._d = {k: None for k in self._OPTS}
 
     # behave like a dict
-    def __iter__(self) -> typing.Iterator[str]:
+    def __iter__(self) -> Iterator[str]:
         return iter(self._d)
 
     def __len__(self) -> int:
@@ -317,10 +314,10 @@ def __contains__(self, key) -> bool:
         except AttributeError:
             return False
 
-    def __getitem__(self, key) -> typing.Any:
+    def __getitem__(self, key) -> Any:
         return getattr(self, key)
 
-    def __setitem__(self, key: str, val: typing.Any) -> None:
+    def __setitem__(self, key: str, val: Any) -> None:
         getattr(ManimConfig, key).fset(self, val)  # fset is the property's setter
 
     def update(self, obj: ManimConfig | dict) -> None:
@@ -395,7 +392,7 @@ def __copy__(self) -> ManimConfig:
         """See ManimConfig.copy()."""
         return copy.deepcopy(self)
 
-    def __deepcopy__(self, memo: dict[str, typing.Any]) -> ManimConfig:
+    def __deepcopy__(self, memo: dict[str, Any]) -> ManimConfig:
         """See ManimConfig.copy()."""
         c = ManimConfig()
         # Deepcopying the underlying dict is enough because all properties
@@ -405,14 +402,14 @@ def __deepcopy__(self, memo: dict[str, typing.Any]) -> ManimConfig:
         return c
 
     # helper type-checking methods
-    def _set_from_list(self, key: str, val: typing.Any, values: list) -> None:
+    def _set_from_list(self, key: str, val: Any, values: list) -> None:
         """Set ``key`` to ``val`` if ``val`` is contained in ``values``."""
         if val in values:
             self._d[key] = val
         else:
             raise ValueError(f"attempted to set {key} to {val}; must be in {values}")
 
-    def _set_boolean(self, key: str | int, val: typing.Any) -> None:
+    def _set_boolean(self, key: str | int, val: Any) -> None:
         """Set ``key`` to ``val`` if ``val`` is Boolean."""
         if val in [True, False]:
             self._d[key] = val
@@ -425,7 +422,7 @@ def _set_tuple(self, key: str, val: tuple) -> None:
         else:
             raise ValueError(f"{key} must be tuple")
 
-    def _set_str(self, key: str, val: typing.Any) -> None:
+    def _set_str(self, key: str, val: Any) -> None:
         """Set ``key`` to ``val`` if ``val`` is a string."""
         if isinstance(val, str):
             self._d[key] = val
@@ -537,7 +534,6 @@ def digest_parser(self, parser: configparser.ConfigParser) -> ManimConfig:
             "flush_cache",
             "custom_folders",
             "use_opengl_renderer",
-            "use_webgl_renderer",
             "enable_gui",
             "fullscreen",
             "use_projection_fill_shaders",
@@ -577,7 +573,6 @@ def digest_parser(self, parser: configparser.ConfigParser) -> ManimConfig:
             "movie_file_extension",
             "background_color",
             "renderer",
-            "webgl_renderer_path",
             "window_position",
         ]:
             setattr(self, key, parser["CLI"].get(key, fallback="", raw=True))
@@ -710,7 +705,6 @@ def digest_args(self, args: argparse.Namespace) -> ManimConfig:
             "renderer",
             "background_color",
             "use_opengl_renderer",
-            "use_webgl_renderer",
             "enable_gui",
             "fullscreen",
             "use_projection_fill_shaders",
@@ -835,8 +829,7 @@ def digest_file(self, filename: str) -> ManimConfig:
                 filename,
             )
 
-        if filename:
-            return self.digest_parser(make_config_parser(filename))
+        return self.digest_parser(make_config_parser(filename))
 
     # config options are properties
     preview = property(
@@ -861,19 +854,11 @@ def digest_file(self, filename: str) -> ManimConfig:
         doc="Whether to show progress bars while rendering animations.",
     )
 
-    @property
-    def log_to_file(self):
-        """Whether to save logs to a file."""
-        return self._d["log_to_file"]
-
-    @log_to_file.setter
-    def log_to_file(self, val: str) -> None:
-        self._set_boolean("log_to_file", val)
-        if val:
-            log_dir = self.get_dir("log_dir")
-            if not os.path.exists(log_dir):
-                os.makedirs(log_dir)
-            set_file_logger(self, self["verbosity"])
+    log_to_file = property(
+        lambda self: self._d["log_to_file"],
+        lambda self, val: self._set_boolean("log_to_file", val),
+        doc="Whether to save logs to a file.",
+    )
 
     notify_outdated_version = property(
         lambda self: self._d["notify_outdated_version"],
@@ -929,12 +914,6 @@ def log_to_file(self, val: str) -> None:
         doc="Set to force window when using the opengl renderer",
     )
 
-    dry_run = property(
-        lambda self: self._d["dry_run"],
-        lambda self, val: self._set_boolean("dry_run", val),
-        doc="Enable dry_run so that no output files are generated and window is disabled.",
-    )
-
     @property
     def verbosity(self):
         """Logger verbosity; "DEBUG", "INFO", "WARNING", "ERROR", or "CRITICAL" (-v)."""
@@ -1181,7 +1160,7 @@ def dry_run(self, val: bool) -> None:
 
     @property
     def renderer(self):
-        """Renderer: "cairo", "opengl", "webgl"""
+        """Renderer: "cairo", "opengl"""
         return self._d["renderer"]
 
     @renderer.setter
@@ -1221,7 +1200,7 @@ def renderer(self, val: str) -> None:
         self._set_from_list(
             "renderer",
             val,
-            ["cairo", "opengl", "webgl"],
+            ["cairo", "opengl"],
         )
 
     @property
@@ -1236,31 +1215,9 @@ def use_opengl_renderer(self, val: bool) -> None:
             self._set_from_list(
                 "renderer",
                 "opengl",
-                ["cairo", "opengl", "webgl"],
+                ["cairo", "opengl"],
             )
 
-    @property
-    def use_webgl_renderer(self):
-        """Whether or not to use WebGL renderer."""
-        return self._d["use_webgl_renderer"]
-
-    @use_webgl_renderer.setter
-    def use_webgl_renderer(self, val: bool) -> None:
-        self._d["use_webgl_renderer"] = val
-        if val:
-            self._set_from_list(
-                "webgl",
-                "renderer",
-                ["cairo", "opengl", "webgl"],
-            )
-            self["disable_caching"] = True
-
-    webgl_renderer_path = property(
-        lambda self: self._d["webgl_renderer_path"],
-        lambda self, val: self._d.__setitem__("webgl_renderer_path", val),
-        doc="Path to WebGL renderer.",
-    )
-
     media_dir = property(
         lambda self: self._d["media_dir"],
         lambda self, val: self._set_dir("media_dir", val),
@@ -1637,15 +1594,15 @@ def __init__(self, c: ManimConfig) -> None:
         self.__dict__["_c"] = c
 
     # there are required by parent class Mapping to behave like a dict
-    def __getitem__(self, key: str | int) -> typing.Any:
+    def __getitem__(self, key: str | int) -> Any:
         if key in self._OPTS:
             return self._c[key]
         elif key in self._CONSTANTS:
             return self._CONSTANTS[key]
         else:
             raise KeyError(key)
 
-    def __iter__(self) -> typing.Iterable:
+    def __iter__(self) -> Iterable:
         return iter(list(self._OPTS) + list(self._CONSTANTS))
 
     def __len__(self) -> int: