manim 0.17.0__py3-none-any.whl → 0.19.1__py3-none-any.whl

manim/__init__.py

@@ -1,14 +1,17 @@
 #!/usr/bin/env python
-
-
 from __future__ import annotations
 
-import pkg_resources
-
-__version__: str = pkg_resources.get_distribution(__name__).version
+from importlib.metadata import PackageNotFoundError, version
 
+# Use installed distribution version if available; otherwise fall back to a
+# sensible default so that importing from a source checkout works without an
+# editable install (pip install -e .).
+try:
+    __version__ = version(__name__)
+except PackageNotFoundError:
+    # Package is not installed; provide a fallback version string.
+    __version__ = "0.0.0+unknown"
 
-import sys
 
 # isort: off
 
@@ -20,6 +23,7 @@ from ._config import *
 from .utils.commands import *
 
 # isort: on
+import numpy as np
 
 from .animation.animation import *
 from .animation.changing import *
@@ -46,6 +50,7 @@ from .constants import *
 from .mobject.frame import *
 from .mobject.geometry.arc import *
 from .mobject.geometry.boolean_ops import *
+from .mobject.geometry.labeled import *
 from .mobject.geometry.line import *
 from .mobject.geometry.polygram import *
 from .mobject.geometry.shape_matchers import *

manim/__main__.py

@@ -1,26 +1,54 @@
 from __future__ import annotations
 
-import sys
-
 import click
 import cloup
 
-from . import __version__, cli_ctx_settings, console
-from .cli.cfg.group import cfg
-from .cli.default_group import DefaultGroup
-from .cli.init.commands import init
-from .cli.new.group import new
-from .cli.plugins.commands import plugins
-from .cli.render.commands import render
-from .constants import EPILOG
+from manim import __version__
+from manim._config import cli_ctx_settings, console
+from manim.cli.cfg.group import cfg
+from manim.cli.checkhealth.commands import checkhealth
+from manim.cli.default_group import DefaultGroup
+from manim.cli.init.commands import init
+from manim.cli.plugins.commands import plugins
+from manim.cli.render.commands import render
+from manim.constants import EPILOG
+
 
+def show_splash(ctx: click.Context, param: click.Option, value: str | None) -> None:
+    """When giving a value by console, show an initial message with the Manim
+    version before executing any other command: ``Manim Community vA.B.C``.
 
-def exit_early(ctx, param, value):
+    Parameters
+    ----------
+    ctx
+        The Click context.
+    param
+        A Click option.
+    value
+        A string value given by console, or None.
+    """
     if value:
-        sys.exit()
+        console.print(f"Manim Community [green]v{__version__}[/green]\n")
+
 
+def print_version_and_exit(
+    ctx: click.Context, param: click.Option, value: str | None
+) -> None:
+    """Same as :func:`show_splash`, but also exit when giving a value by
+    console.
 
-console.print(f"Manim Community [green]v{__version__}[/green]\n")
+    Parameters
+    ----------
+    ctx
+        The Click context.
+    param
+        A Click option.
+    value
+        A string value given by console, or None.
+    """
+    show_splash(ctx, param, value)
+    if value:
+        ctx.exit()
 
 
 @cloup.group(
@@ -34,24 +62,39 @@ console.print(f"Manim Community [green]v{__version__}[/green]\n")
     "is specified. Run 'manim render --help' if you would like to know what the "
     f"'-ql' or '-p' flags do, for example.\n\n{EPILOG}",
 )
-@click.option(
+@cloup.option(
     "--version",
     is_flag=True,
     help="Show version and exit.",
-    callback=exit_early,
+    callback=print_version_and_exit,
     is_eager=True,
     expose_value=False,
 )
-@click.pass_context
-def main(ctx):
-    """The entry point for manim."""
+@click.option(
+    "--show-splash/--hide-splash",
+    is_flag=True,
+    default=True,
+    help="Print splash message with version information.",
+    callback=show_splash,
+    is_eager=True,
+    expose_value=False,
+)
+@cloup.pass_context
+def main(ctx: click.Context) -> None:
+    """The entry point for Manim.
+
+    Parameters
+    ----------
+    ctx
+        The Click context.
+    """
     pass
 
 
+main.add_command(checkhealth)
 main.add_command(cfg)
 main.add_command(plugins)
 main.add_command(init)
-main.add_command(new)
 main.add_command(render)
 
 if __name__ == "__main__":

manim/_config/__init__.py

@@ -3,7 +3,9 @@
 from __future__ import annotations
 
 import logging
-from contextlib import _GeneratorContextManager, contextmanager
+from collections.abc import Generator
+from contextlib import contextmanager
+from typing import Any
 
 from .cli_colors import parse_cli_ctx
 from .logger_utils import make_logger
@@ -20,12 +22,10 @@ __all__ = [
 ]
 
 parser = make_config_parser()
-logger: logging.Logger
 
-# 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().
-# Use error_console to print errors so that it outputs to stderr.
+# Logger usage: accessible globally as `manim.logger` or via `logging.getLogger("manim")`.
+# For printing, use `manim.console.print()` instead of the built-in `print()`.
+# For error output, use `error_console`, which prints to stderr.
 logger, console, error_console = make_logger(
     parser["logger"],
     parser["CLI"]["verbosity"],
@@ -36,13 +36,15 @@ logging.getLogger("PIL").setLevel(logging.INFO)
 logging.getLogger("matplotlib").setLevel(logging.INFO)
 
 config = ManimConfig().digest_parser(parser)
+# TODO: to be used in the future - see PR #620
+# https://github.com/ManimCommunity/manim/pull/620
 frame = ManimFrame(config)
 
 
 # This has to go here because it needs access to this module's config
 @contextmanager
-def tempconfig(temp: ManimConfig | dict) -> _GeneratorContextManager:
-    """Context manager that temporarily modifies the global ``config`` object.
+def tempconfig(temp: ManimConfig | dict[str, Any]) -> Generator[None, None, None]:
+    """Temporarily modifies the global ``config`` object using a context manager.
 
     Inside the ``with`` statement, the modified config will be used.  After
     context manager exits, the config will be restored to its original state.
@@ -65,7 +67,6 @@ def tempconfig(temp: ManimConfig | dict) -> _GeneratorContextManager:
        8.0
        >>> with tempconfig({"frame_height": 100.0}):
        ...     print(config["frame_height"])
-       ...
        100.0
        >>> config["frame_height"]
        8.0

manim/_config/cli_colors.py

@@ -1,10 +1,21 @@
+"""Parses CLI context settings from the configuration file and returns a Cloup Context settings dictionary.
+
+This module reads configuration values for help formatting, theme styles, and alignment options
+used when rendering command-line interfaces in Manim.
+"""
+
+from __future__ import annotations
+
 import configparser
+from typing import Any
 
 from cloup import Context, HelpFormatter, HelpTheme, Style
 
+__all__ = ["parse_cli_ctx"]
 
-def parse_cli_ctx(parser: configparser.ConfigParser) -> Context:
-    formatter_settings = {
+
+def parse_cli_ctx(parser: configparser.SectionProxy) -> dict[str, Any]:
+    formatter_settings: dict[str, str | int | None] = {
         "indent_increment": int(parser["indent_increment"]),
         "width": int(parser["width"]),
         "col1_max_width": int(parser["col1_max_width"]),
@@ -23,6 +34,7 @@ def parse_cli_ctx(parser: configparser.ConfigParser) -> Context:
         "col2",
         "epilog",
     }
+    # Extract and apply any style-related keys defined in the config section.
     for k, v in parser.items():
         if k in theme_keys and v:
             theme_settings.update({k: Style(v)})
@@ -30,21 +42,26 @@ def parse_cli_ctx(parser: configparser.ConfigParser) -> Context:
     formatter = {}
     theme = parser["theme"] if parser["theme"] else None
     if theme is None:
-        formatter = HelpFormatter().settings(
-            theme=HelpTheme(**theme_settings), **formatter_settings
+        formatter = HelpFormatter.settings(
+            theme=HelpTheme(**theme_settings),
+            **formatter_settings,
         )
     elif theme.lower() == "dark":
-        formatter = HelpFormatter().settings(
-            theme=HelpTheme.dark().with_(**theme_settings), **formatter_settings
+        formatter = HelpFormatter.settings(
+            theme=HelpTheme.dark().with_(**theme_settings),
+            **formatter_settings,
         )
     elif theme.lower() == "light":
-        formatter = HelpFormatter().settings(
-            theme=HelpTheme.light().with_(**theme_settings), **formatter_settings
+        formatter = HelpFormatter.settings(
+            theme=HelpTheme.light().with_(**theme_settings),
+            **formatter_settings,
         )
 
-    return Context.settings(
+    return_val: dict[str, Any] = Context.settings(
         align_option_groups=parser["align_option_groups"].lower() == "true",
         align_sections=parser["align_sections"].lower() == "true",
         show_constraints=True,
         formatter_settings=formatter,
     )
+
+    return return_val

manim/_config/default.cfg

@@ -221,9 +221,7 @@ repr_number = green
 # Uncomment the following line to manually set the loglevel for ffmpeg. See
 # ffmpeg manpage for accepted values
 loglevel = ERROR
-# defaults to the one present in path
-ffmpeg_executable = ffmpeg
 
 [jupyter]
-media_embed =
+media_embed = False
 media_width = 60%%

manim/_config/logger_utils.py

@@ -9,14 +9,14 @@ Both ``logger`` and ``console`` use the ``rich`` library to produce rich text
 format.
 
 """
+
 from __future__ import annotations
 
 import configparser
 import copy
 import json
 import logging
-import sys
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from rich import color, errors
 from rich import print as printf
@@ -26,6 +26,9 @@ from rich.theme import Theme
 
 if TYPE_CHECKING:
     from pathlib import Path
+
+__all__ = ["make_logger", "parse_theme", "set_file_logger", "JSONFormatter"]
+
 HIGHLIGHTED_KEYWORDS = [  # these keywords are highlighted specially
     "Played",
     "animations",
@@ -49,9 +52,9 @@ Loading the default color configuration.[/logging.level.error]
 
 
 def make_logger(
-    parser: configparser.ConfigParser,
+    parser: configparser.SectionProxy,
     verbosity: str,
-) -> tuple[logging.Logger, Console]:
+) -> tuple[logging.Logger, Console, Console]:
     """Make the manim logger and console.
 
     Parameters
@@ -83,25 +86,29 @@ def make_logger(
     theme = parse_theme(parser)
     console = Console(theme=theme)
 
-    # With rich 9.5.0+ we could pass stderr=True instead
-    error_console = Console(theme=theme, file=sys.stderr)
+    error_console = Console(theme=theme, stderr=True)
 
     # set the rich handler
-    RichHandler.KEYWORDS = HIGHLIGHTED_KEYWORDS
     rich_handler = RichHandler(
         console=console,
-        show_time=parser.getboolean("log_timestamps"),
+        show_time=parser.getboolean("log_timestamps", fallback=False),
+        keywords=HIGHLIGHTED_KEYWORDS,
     )
 
     # finally, the logger
     logger = logging.getLogger("manim")
     logger.addHandler(rich_handler)
     logger.setLevel(verbosity)
+    logger.propagate = False
+
+    if not (libav_logger := logging.getLogger()).hasHandlers():
+        libav_logger.addHandler(rich_handler)
+        libav_logger.setLevel(verbosity)
 
     return logger, console, error_console
 
 
-def parse_theme(parser: configparser.ConfigParser) -> Theme:
+def parse_theme(parser: configparser.SectionProxy) -> Theme | None:
     """Configure the rich style of logger and console output.
 
     Parameters
@@ -119,7 +126,7 @@ def parse_theme(parser: configparser.ConfigParser) -> Theme:
     :func:`make_logger`.
 
     """
-    theme = {key.replace("_", "."): parser[key] for key in parser}
+    theme: dict[str, Any] = {key.replace("_", "."): parser[key] for key in parser}
 
     theme["log.width"] = None if theme["log.width"] == "-1" else int(theme["log.width"])
     theme["log.height"] = (
@@ -177,12 +184,15 @@ class JSONFormatter(logging.Formatter):
 
     """
 
-    def format(self, record: dict) -> str:
+    def format(self, record: logging.LogRecord) -> str:
         """Format the record in a custom JSON format."""
         record_c = copy.deepcopy(record)
         if record_c.args:
-            for arg in record_c.args:
-                record_c.args[arg] = "<>"
+            if isinstance(record_c.args, dict):
+                for arg in record_c.args:
+                    record_c.args[arg] = "<>"
+            else:
+                record_c.args = ("<>",) * len(record_c.args)
         return json.dumps(
             {
                 "levelname": record_c.levelname,