manim 0.18.0.post0__py3-none-any.whl → 0.19.0__py3-none-any.whl

manim/camera/camera.py

@@ -1,6 +1,5 @@
 """A camera converts the mobjects contained in a Scene into an array of pixels."""
 
-
 from __future__ import annotations
 
 __all__ = ["Camera", "BackgroundColoredVMobjectDisplayer"]
@@ -9,8 +8,9 @@ import copy
 import itertools as it
 import operator as op
 import pathlib
+from collections.abc import Iterable
 from functools import reduce
-from typing import Any, Callable, Iterable
+from typing import Any, Callable
 
 import cairo
 import numpy as np
@@ -37,6 +37,14 @@ LINE_JOIN_MAP = {
 }
 
 
+CAP_STYLE_MAP = {
+    CapStyleType.AUTO: None,  # TODO: this could be improved
+    CapStyleType.ROUND: cairo.LineCap.ROUND,
+    CapStyleType.BUTT: cairo.LineCap.BUTT,
+    CapStyleType.SQUARE: cairo.LineCap.SQUARE,
+}
+
+
 class Camera:
     """Base camera class.
 
@@ -369,7 +377,6 @@ class Camera:
         np.array
             The pixel array which can then be passed to set_background.
         """
-
         logger.info("Starting set_background")
         coords = self.get_coords_of_all_pixels()
         new_background = np.apply_along_axis(coords_to_colors_func, 2, coords)
@@ -778,11 +785,13 @@ class Camera:
         ctx.set_line_width(
             width
             * self.cairo_line_width_multiple
-            # This ensures lines have constant width as you zoom in on them.
             * (self.frame_width / self.frame_width),
+            # This ensures lines have constant width as you zoom in on them.
         )
         if vmobject.joint_type != LineJointType.AUTO:
             ctx.set_line_join(LINE_JOIN_MAP[vmobject.joint_type])
+        if vmobject.cap_style != CapStyleType.AUTO:
+            ctx.set_line_cap(CAP_STYLE_MAP[vmobject.cap_style])
         ctx.stroke_preserve()
         return self
 
@@ -973,8 +982,8 @@ class Camera:
         sub_image = Image.fromarray(image_mobject.get_pixel_array(), mode="RGBA")
 
         # Reshape
-        pixel_width = max(int(pdist([ul_coords, ur_coords])), 1)
-        pixel_height = max(int(pdist([ul_coords, dl_coords])), 1)
+        pixel_width = max(int(pdist([ul_coords, ur_coords]).item()), 1)
+        pixel_height = max(int(pdist([ul_coords, dl_coords]).item()), 1)
         sub_image = sub_image.resize(
             (pixel_width, pixel_height),
             resample=image_mobject.resampling_algorithm,

manim/cli/__init__.py

@@ -0,0 +1,17 @@
+"""The Manim CLI, and the available commands for ``manim``.
+
+This page is a work in progress. Please run ``manim`` or ``manim --help`` in
+your terminal to find more information on the following commands.
+
+Available commands
+------------------
+
+.. autosummary::
+   :toctree: ../reference
+
+   cfg
+   checkhealth
+   init
+   plugins
+   render
+"""

manim/cli/cfg/group.py

@@ -5,32 +5,45 @@ cfg``. Here you can specify options, subcommands, and subgroups for the cfg
 group.
 
 """
+
 from __future__ import annotations
 
-import os
+import contextlib
 from ast import literal_eval
 from pathlib import Path
+from typing import Any, cast
 
-import click
 import cloup
 from rich.errors import StyleSyntaxError
 from rich.style import Style
 
-from ... import cli_ctx_settings, console
-from ..._config.utils import config_file_paths, make_config_parser
-from ...constants import EPILOG
-from ...utils.file_ops import guarantee_existence, open_file
+from manim._config import cli_ctx_settings, console
+from manim._config.utils import config_file_paths, make_config_parser
+from manim.constants import EPILOG
+from manim.utils.file_ops import guarantee_existence, open_file
 
 RICH_COLOUR_INSTRUCTIONS: str = """
 [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]
 """
-RICH_NON_STYLE_ENTRIES: str = ["log.width", "log.height", "log.timestamps"]
+RICH_NON_STYLE_ENTRIES: list[str] = ["log.width", "log.height", "log.timestamps"]
+
+__all__ = [
+    "value_from_string",
+    "value_from_string",
+    "is_valid_style",
+    "replace_keys",
+    "cfg",
+    "write",
+    "show",
+    "export",
+]
 
 
 def value_from_string(value: str) -> str | int | bool:
-    """Extracts the literal of proper datatype from a string.
+    """Extract the literal of proper datatype from a ``value`` string.
+
     Parameters
     ----------
     value
@@ -38,51 +51,60 @@ def value_from_string(value: str) -> str | int | bool:
 
     Returns
     -------
-    Union[:class:`str`, :class:`int`, :class:`bool`]
-        Returns the literal of appropriate datatype.
+    :class:`str` | :class:`int` | :class:`bool`
+        The literal of appropriate datatype.
     """
-    try:
+    with contextlib.suppress(SyntaxError, ValueError):
         value = literal_eval(value)
-    except (SyntaxError, ValueError):
-        pass
     return value
 
 
-def _is_expected_datatype(value: str, expected: str, style: bool = False) -> bool:
-    """Checks whether `value` is the same datatype as `expected`,
-    and checks if it is a valid `style` if `style` is true.
+def _is_expected_datatype(
+    value: str, expected: str, validate_style: bool = False
+) -> bool:
+    """Check whether the literal from ``value`` is the same datatype as the
+    literal from ``expected``. If ``validate_style`` is ``True``, also check if
+    the style given by ``value`` is valid, according to ``rich``.
 
     Parameters
     ----------
     value
-        The string of the value to check (obtained from reading the user input).
+        The string of the value to check, obtained from reading the user input.
     expected
-        The string of the literal datatype must be matched by `value`. Obtained from
-        reading the cfg file.
-    style
-        Whether or not to confirm if `value` is a style, by default False
+        The string of the literal datatype which must be matched by ``value``.
+        This is obtained from reading the ``cfg`` file.
+    validate_style
+        Whether or not to confirm if ``value`` is a valid style, according to
+        ``rich``. Default is ``False``.
 
     Returns
     -------
     :class:`bool`
-        Whether or not `value` matches the datatype of `expected`.
+        Whether or not the literal from ``value`` matches the datatype of the
+        literal from ``expected``.
     """
-    value = value_from_string(value)
-    expected = type(value_from_string(expected))
+    value_literal = value_from_string(value)
+    ExpectedLiteralType = type(value_from_string(expected))
 
-    return isinstance(value, expected) and (is_valid_style(value) if style else True)
+    return isinstance(value_literal, ExpectedLiteralType) and (
+        (isinstance(value_literal, str) and is_valid_style(value_literal))
+        if validate_style
+        else True
+    )
 
 
 def is_valid_style(style: str) -> bool:
-    """Checks whether the entered color is a valid color according to rich
+    """Checks whether the entered color style is valid, according to ``rich``.
+
     Parameters
     ----------
     style
         The style to check whether it is valid.
+
     Returns
     -------
-    Boolean
-        Returns whether it is valid style or not according to rich.
+    :class:`bool`
+        Whether the color style is valid or not, according to ``rich``.
     """
     try:
         Style.parse(style)
@@ -91,16 +113,20 @@ def is_valid_style(style: str) -> bool:
         return False
 
 
-def replace_keys(default: dict) -> dict:
-    """Replaces _ to . and vice versa in a dictionary for rich
+def replace_keys(default: dict[str, Any]) -> dict[str, Any]:
+    """Replace ``_`` with ``.`` and vice versa in a dictionary's keys for
+    ``rich``.
+
     Parameters
     ----------
     default
-        The dictionary to check and replace
+        The dictionary whose keys will be checked and replaced.
+
     Returns
     -------
     :class:`dict`
-        The dictionary which is modified by replacing _ with . and vice versa
+        The dictionary whose keys are modified by replacing ``_`` with ``.``
+        and vice versa.
     """
     for key in default:
         if "_" in key:
@@ -123,22 +149,22 @@ def replace_keys(default: dict) -> dict:
     epilog=EPILOG,
     help="Manages Manim configuration files.",
 )
-@click.pass_context
-def cfg(ctx):
+@cloup.pass_context
+def cfg(ctx: cloup.Context) -> None:
     """Responsible for the cfg subcommand."""
     pass
 
 
 @cfg.command(context_settings=cli_ctx_settings, no_args_is_help=True)
-@click.option(
+@cloup.option(
     "-l",
     "--level",
-    type=click.Choice(["user", "cwd"], case_sensitive=False),
+    type=cloup.Choice(["user", "cwd"], case_sensitive=False),
     default="cwd",
     help="Specify if this config is for user or the working directory.",
 )
-@click.option("-o", "--open", "openfile", is_flag=True)
-def write(level: str = None, openfile: bool = False) -> None:
+@cloup.option("-o", "--open", "openfile", is_flag=True)
+def write(level: str | None = None, openfile: bool = False) -> None:
     config_paths = config_file_paths()
     console.print(
         "[yellow bold]Manim Configuration File Writer[/yellow bold]",
@@ -157,7 +183,7 @@ To save your config please save that file and place it in your current working d
         action = "save this as"
         for category in parser:
             console.print(f"{category}", style="bold green underline")
-            default = parser[category]
+            default = cast(dict[str, Any], parser[category])
             if category == "logger":
                 console.print(RICH_COLOUR_INSTRUCTIONS)
                 default = replace_keys(default)
@@ -187,7 +213,7 @@ To save your config please save that file and place it in your current working d
                         """Not enough values in input.
 You may have added a new entry to default.cfg, in which case you will have to
 modify write_cfg_subcmd_input to account for it.""",
-                    )
+                    ) from None
                 if temp:
                     while temp and not _is_expected_datatype(
                         temp,
@@ -240,7 +266,7 @@ modify write_cfg_subcmd_input to account for it.""",
 
 
 @cfg.command(context_settings=cli_ctx_settings)
-def show():
+def show() -> None:
     parser = make_config_parser()
     rich_non_style_entries = [a.replace(".", "_") for a in RICH_NON_STYLE_ENTRIES]
     for category in parser:
@@ -258,9 +284,9 @@ def show():
 
 
 @cfg.command(context_settings=cli_ctx_settings)
-@click.option("-d", "--directory", default=Path.cwd())
-@click.pass_context
-def export(ctx, directory):
+@cloup.option("-d", "--directory", default=Path.cwd())
+@cloup.pass_context
+def export(ctx: cloup.Context, directory: str) -> None:
     directory_path = Path(directory)
     if directory_path.absolute == Path.cwd().absolute:
         console.print(

manim/cli/checkhealth/checks.py

@@ -1,63 +1,79 @@
 """Auxiliary module for the checkhealth subcommand, contains
-the actual check implementations."""
+the actual check implementations.
+"""
 
 from __future__ import annotations
 
 import os
 import shutil
-import subprocess
-from typing import Callable
+from typing import Callable, Protocol, cast
 
-from ..._config import config
+__all__ = ["HEALTH_CHECKS"]
 
-HEALTH_CHECKS = []
+
+class HealthCheckFunction(Protocol):
+    description: str
+    recommendation: str
+    skip_on_failed: list[str]
+    post_fail_fix_hook: Callable[..., object] | None
+    __name__: str
+
+    def __call__(self) -> bool: ...
+
+
+HEALTH_CHECKS: list[HealthCheckFunction] = []
 
 
 def healthcheck(
     description: str,
     recommendation: str,
-    skip_on_failed: list[Callable | str] | None = None,
-    post_fail_fix_hook: Callable | None = None,
-):
+    skip_on_failed: list[HealthCheckFunction | str] | None = None,
+    post_fail_fix_hook: Callable[..., object] | None = None,
+) -> Callable[[Callable[[], bool]], HealthCheckFunction]:
     """Decorator used for declaring health checks.
 
-    This decorator attaches some data to a function,
-    which is then added to a list containing all checks.
+    This decorator attaches some data to a function, which is then added to a
+    a list containing all checks.
 
     Parameters
     ----------
     description
-        A brief description of this check, displayed when
-        the checkhealth subcommand is run.
+        A brief description of this check, displayed when the ``checkhealth``
+        subcommand is run.
     recommendation
         Help text which is displayed in case the check fails.
     skip_on_failed
-        A list of check functions which, if they fail, cause
-        the current check to be skipped.
+        A list of check functions which, if they fail, cause the current check
+        to be skipped.
     post_fail_fix_hook
-        A function that is supposed to (interactively) help
-        to fix the detected problem, if possible. This is
-        only called upon explicit confirmation of the user.
+        A function that is meant to (interactively) help to fix the detected
+        problem, if possible. This is only called upon explicit confirmation of
+        the user.
 
     Returns
     -------
-    A check function, as required by the checkhealth subcommand.
+    Callable[Callable[[], bool], :class:`HealthCheckFunction`]
+        A decorator which converts a function into a health check function, as
+        required by the ``checkhealth`` subcommand.
     """
+    new_skip_on_failed: list[str]
     if skip_on_failed is None:
-        skip_on_failed = []
-    skip_on_failed = [
-        skip.__name__ if callable(skip) else skip for skip in skip_on_failed
-    ]
+        new_skip_on_failed = []
+    else:
+        new_skip_on_failed = [
+            skip.__name__ if callable(skip) else skip for skip in skip_on_failed
+        ]
 
-    def decorator(func):
-        func.description = description
-        func.recommendation = recommendation
-        func.skip_on_failed = skip_on_failed
-        func.post_fail_fix_hook = post_fail_fix_hook
-        HEALTH_CHECKS.append(func)
-        return func
+    def wrapper(func: Callable[[], bool]) -> HealthCheckFunction:
+        health_func = cast(HealthCheckFunction, func)
+        health_func.description = description
+        health_func.recommendation = recommendation
+        health_func.skip_on_failed = new_skip_on_failed
+        health_func.post_fail_fix_hook = post_fail_fix_hook
+        HEALTH_CHECKS.append(health_func)
+        return health_func
 
-    return decorator
+    return wrapper
 
 
 @healthcheck(
@@ -75,7 +91,14 @@ def healthcheck(
         "PATH variable."
     ),
 )
-def is_manim_on_path():
+def is_manim_on_path() -> bool:
+    """Check whether ``manim`` is in ``PATH``.
+
+    Returns
+    -------
+    :class:`bool`
+        Whether ``manim`` is in ``PATH`` or not.
+    """
     path_to_manim = shutil.which("manim")
     return path_to_manim is not None
 
@@ -91,10 +114,30 @@ def is_manim_on_path():
     ),
     skip_on_failed=[is_manim_on_path],
 )
-def is_manim_executable_associated_to_this_library():
+def is_manim_executable_associated_to_this_library() -> bool:
+    """Check whether the ``manim`` executable in ``PATH`` is associated to this
+    library. To verify this, the executable should look like this:
+
+    .. code-block:: python
+
+        #!<MANIM_PATH>/.../python
+        import sys
+        from manim.__main__ import main
+
+        if __name__ == "__main__":
+            sys.exit(main())
+
+
+    Returns
+    -------
+    :class:`bool`
+        Whether the ``manim`` executable in ``PATH`` is associated to this
+        library or not.
+    """
     path_to_manim = shutil.which("manim")
-    with open(path_to_manim, "rb") as f:
-        manim_exec = f.read()
+    assert path_to_manim is not None
+    with open(path_to_manim, "rb") as manim_binary:
+        manim_exec = manim_binary.read()
 
     # first condition below corresponds to the executable being
     # some sort of python script. second condition happens when
@@ -102,45 +145,6 @@ def is_manim_executable_associated_to_this_library():
     return b"manim.__main__" in manim_exec or b'"%~dp0\\manim"' in manim_exec
 
 
-@healthcheck(
-    description="Checking whether ffmpeg is available",
-    recommendation=(
-        "Manim does not work without ffmpeg. Please follow our "
-        "installation instructions "
-        "at https://docs.manim.community/en/stable/installation.html "
-        "to download ffmpeg. Then, either ...\n\n"
-        "(a) ... make the ffmpeg executable available to your system's PATH,\n"
-        "(b) or, alternatively, use <manim cfg write --open> to create a "
-        "custom configuration and set the ffmpeg_executable variable to the "
-        "full absolute path to the ffmpeg executable."
-    ),
-)
-def is_ffmpeg_available():
-    path_to_ffmpeg = shutil.which(config.ffmpeg_executable)
-    return path_to_ffmpeg is not None and os.access(path_to_ffmpeg, os.X_OK)
-
-
-@healthcheck(
-    description="Checking whether ffmpeg is working",
-    recommendation=(
-        "Your installed version of ffmpeg does not support x264 encoding, "
-        "which manim requires. Please follow our installation instructions "
-        "at https://docs.manim.community/en/stable/installation.html "
-        "to download and install a newer version of ffmpeg."
-    ),
-    skip_on_failed=[is_ffmpeg_available],
-)
-def is_ffmpeg_working():
-    ffmpeg_version = subprocess.run(
-        [config.ffmpeg_executable, "-version"],
-        stdout=subprocess.PIPE,
-    ).stdout.decode()
-    return (
-        ffmpeg_version.startswith("ffmpeg version")
-        and "--enable-libx264" in ffmpeg_version
-    )
-
-
 @healthcheck(
     description="Checking whether latex is available",
     recommendation=(
@@ -153,7 +157,14 @@ def is_ffmpeg_working():
         "LaTeX distribution on your operating system."
     ),
 )
-def is_latex_available():
+def is_latex_available() -> bool:
+    """Check whether ``latex`` is in ``PATH`` and can be executed.
+
+    Returns
+    -------
+    :class:`bool`
+        Whether ``latex`` is in ``PATH`` and can be executed or not.
+    """
     path_to_latex = shutil.which("latex")
     return path_to_latex is not None and os.access(path_to_latex, os.X_OK)
 
@@ -168,6 +179,13 @@ def is_latex_available():
     ),
     skip_on_failed=[is_latex_available],
 )
-def is_dvisvgm_available():
+def is_dvisvgm_available() -> bool:
+    """Check whether ``dvisvgm`` is in ``PATH`` and can be executed.
+
+    Returns
+    -------
+    :class:`bool`
+        Whether ``dvisvgm`` is in ``PATH`` and can be executed or not.
+    """
     path_to_dvisvgm = shutil.which("dvisvgm")
     return path_to_dvisvgm is not None and os.access(path_to_dvisvgm, os.X_OK)

manim/cli/checkhealth/commands.py

@@ -6,23 +6,26 @@ your Manim installation.
 from __future__ import annotations
 
 import sys
+import timeit
 
 import click
 import cloup
 
-from .checks import HEALTH_CHECKS
+from manim.cli.checkhealth.checks import HEALTH_CHECKS, HealthCheckFunction
+
+__all__ = ["checkhealth"]
 
 
 @cloup.command(
     context_settings=None,
 )
-def checkhealth():
+def checkhealth() -> None:
     """This subcommand checks whether Manim is installed correctly
     and has access to its required (and optional) system dependencies.
     """
     click.echo(f"Python executable: {sys.executable}\n")
     click.echo("Checking whether your installation of Manim Community is healthy...")
-    failed_checks = []
+    failed_checks: list[HealthCheckFunction] = []
 
     for check in HEALTH_CHECKS:
         click.echo(f"- {check.description} ... ", nl=False)
@@ -60,7 +63,7 @@ def checkhealth():
             import manim as mn
 
             class CheckHealthDemo(mn.Scene):
-                def construct(self):
+                def _inner_construct(self) -> None:
                     banner = mn.ManimBanner().shift(mn.UP * 0.5)
                     self.play(banner.create())
                     self.wait(0.5)
@@ -77,5 +80,11 @@ def checkhealth():
                         mn.FadeOut(text_tex_group, shift=mn.DOWN),
                     )
 
+                def construct(self) -> None:
+                    self.execution_time = timeit.timeit(self._inner_construct, number=1)
+
             with mn.tempconfig({"preview": True, "disable_caching": True}):
-                CheckHealthDemo().render()
+                scene = CheckHealthDemo()
+                scene.render()
+
+                click.echo(f"Scene rendered in {scene.execution_time:.2f} seconds.")