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

manim/cli/checkhealth/checks.py

@@ -0,0 +1,173 @@
+"""Auxiliary module for the checkhealth subcommand, contains
+the actual check implementations."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+from typing import Callable
+
+from ..._config import config
+
+HEALTH_CHECKS = []
+
+
+def healthcheck(
+    description: str,
+    recommendation: str,
+    skip_on_failed: list[Callable | str] | None = None,
+    post_fail_fix_hook: Callable | None = None,
+):
+    """Decorator used for declaring health checks.
+
+    This decorator attaches some data to a function,
+    which is then added to a list containing all checks.
+
+    Parameters
+    ----------
+    description
+        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.
+    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.
+
+    Returns
+    -------
+    A check function, as required by the checkhealth subcommand.
+    """
+    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
+    ]
+
+    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
+
+    return decorator
+
+
+@healthcheck(
+    description="Checking whether manim is on your PATH",
+    recommendation=(
+        "The command <manim> is currently not on your system's PATH.\n\n"
+        "You can work around this by calling the manim module directly "
+        "via <python -m manim> instead of just <manim>.\n\n"
+        "To fix the PATH issue properly: "
+        "Usually, the Python package installer pip issues a warning "
+        "during the installation which contains more information. "
+        "Consider reinstalling manim via <pip uninstall manim> "
+        "followed by <pip install manim> to see the warning again, "
+        "then consult the internet on how to modify your system's "
+        "PATH variable."
+    ),
+)
+def is_manim_on_path():
+    path_to_manim = shutil.which("manim")
+    return path_to_manim is not None
+
+
+@healthcheck(
+    description="Checking whether the executable belongs to manim",
+    recommendation=(
+        "The command <manim> does not belong to your installed version "
+        "of this library, it likely belongs to manimgl / manimlib.\n\n"
+        "Run manim via <python -m manim> or via <manimce>, or uninstall "
+        "and reinstall manim via <pip install --upgrade "
+        "--force-reinstall manim> to fix this."
+    ),
+    skip_on_failed=[is_manim_on_path],
+)
+def is_manim_executable_associated_to_this_library():
+    path_to_manim = shutil.which("manim")
+    with open(path_to_manim, "rb") as f:
+        manim_exec = f.read()
+
+    # first condition below corresponds to the executable being
+    # some sort of python script. second condition happens when
+    # the executable is actually a Windows batch file.
+    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=(
+        "Manim cannot find <latex> on your system's PATH. "
+        "You will not be able to use Tex and MathTex mobjects "
+        "in your scenes.\n\n"
+        "Consult our installation instructions "
+        "at https://docs.manim.community/en/stable/installation.html "
+        "or search the web for instructions on how to install a "
+        "LaTeX distribution on your operating system."
+    ),
+)
+def is_latex_available():
+    path_to_latex = shutil.which("latex")
+    return path_to_latex is not None and os.access(path_to_latex, os.X_OK)
+
+
+@healthcheck(
+    description="Checking whether dvisvgm is available",
+    recommendation=(
+        "Manim could find <latex>, but not <dvisvgm> on your system's "
+        "PATH. Make sure your installed LaTeX distribution comes with "
+        "dvisvgm and consider installing a larger distribution if it "
+        "does not."
+    ),
+    skip_on_failed=[is_latex_available],
+)
+def is_dvisvgm_available():
+    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

@@ -0,0 +1,81 @@
+"""A CLI utility helping to diagnose problems with
+your Manim installation.
+
+"""
+
+from __future__ import annotations
+
+import sys
+
+import click
+import cloup
+
+from .checks import HEALTH_CHECKS
+
+
+@cloup.command(
+    context_settings=None,
+)
+def checkhealth():
+    """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 = []
+
+    for check in HEALTH_CHECKS:
+        click.echo(f"- {check.description} ... ", nl=False)
+        if any(
+            failed_check.__name__ in check.skip_on_failed
+            for failed_check in failed_checks
+        ):
+            click.secho("SKIPPED", fg="blue")
+            continue
+        check_result = check()
+        if check_result:
+            click.secho("PASSED", fg="green")
+        else:
+            click.secho("FAILED", fg="red")
+            failed_checks.append(check)
+
+    click.echo()
+
+    if failed_checks:
+        click.echo(
+            "There are problems with your installation, "
+            "here are some recommendations to fix them:"
+        )
+        for ind, failed_check in enumerate(failed_checks):
+            click.echo(failed_check.recommendation)
+            if ind + 1 < len(failed_checks):
+                click.confirm("Continue with next recommendation?")
+
+    else:  # no problems detected!
+        click.echo("No problems detected, your installation seems healthy!")
+        render_test_scene = click.confirm(
+            "Would you like to render and preview a test scene?"
+        )
+        if render_test_scene:
+            import manim as mn
+
+            class CheckHealthDemo(mn.Scene):
+                def construct(self):
+                    banner = mn.ManimBanner().shift(mn.UP * 0.5)
+                    self.play(banner.create())
+                    self.wait(0.5)
+                    self.play(banner.expand())
+                    self.wait(0.5)
+                    text_left = mn.Text("All systems operational!")
+                    formula_right = mn.MathTex(r"\oint_{\gamma} f(z)~dz = 0")
+                    text_tex_group = mn.VGroup(text_left, formula_right)
+                    text_tex_group.arrange(mn.RIGHT, buff=1).next_to(banner, mn.DOWN)
+                    self.play(mn.Write(text_tex_group))
+                    self.wait(0.5)
+                    self.play(
+                        mn.FadeOut(banner, shift=mn.UP),
+                        mn.FadeOut(text_tex_group, shift=mn.DOWN),
+                    )
+
+            with mn.tempconfig({"preview": True, "disable_caching": True}):
+                CheckHealthDemo().render()

manim/cli/render/global_options.py

@@ -102,4 +102,10 @@ global_options: OptionGroupDecorator = option_group(
         help="Renders animations without outputting image or video files and disables the window",
         default=False,
     ),
+    option(
+        "--no_latex_cleanup",
+        is_flag=True,
+        help="Prevents deletion of .aux, .dvi, and .log files produced by Tex and MathTex.",
+        default=False,
+    ),
 )

manim/constants.py

@@ -10,6 +10,8 @@ import numpy as np
 from cloup import Context
 from PIL.Image import Resampling
 
+from manim.typing import Vector3
+
 __all__ = [
     "SCENE_NOT_FOUND_MESSAGE",
     "CHOOSE_NUMBER_MESSAGE",
@@ -62,6 +64,7 @@ __all__ = [
     "DEFAULT_POINT_DENSITY_1D",
     "DEFAULT_STROKE_WIDTH",
     "DEFAULT_FONT_SIZE",
+    "SCALE_FACTOR_PER_FONT_POINT",
     "PI",
     "TAU",
     "DEGREES",
@@ -76,34 +79,34 @@ __all__ = [
 ]
 # Messages
 
-SCENE_NOT_FOUND_MESSAGE: str = """
+SCENE_NOT_FOUND_MESSAGE = """
    {} is not in the script
 """
-CHOOSE_NUMBER_MESSAGE: str = """
+CHOOSE_NUMBER_MESSAGE = """
 Choose number corresponding to desired scene/arguments.
 (Use comma separated list for multiple entries)
 Choice(s): """
-INVALID_NUMBER_MESSAGE: str = "Invalid scene numbers have been specified. Aborting."
-NO_SCENE_MESSAGE: str = """
+INVALID_NUMBER_MESSAGE = "Invalid scene numbers have been specified. Aborting."
+NO_SCENE_MESSAGE = """
    There are no scenes inside that module
 """
 
 # Pango stuff
-NORMAL: str = "NORMAL"
-ITALIC: str = "ITALIC"
-OBLIQUE: str = "OBLIQUE"
-BOLD: str = "BOLD"
+NORMAL = "NORMAL"
+ITALIC = "ITALIC"
+OBLIQUE = "OBLIQUE"
+BOLD = "BOLD"
 # Only for Pango from below
-THIN: str = "THIN"
-ULTRALIGHT: str = "ULTRALIGHT"
-LIGHT: str = "LIGHT"
-SEMILIGHT: str = "SEMILIGHT"
-BOOK: str = "BOOK"
-MEDIUM: str = "MEDIUM"
-SEMIBOLD: str = "SEMIBOLD"
-ULTRABOLD: str = "ULTRABOLD"
-HEAVY: str = "HEAVY"
-ULTRAHEAVY: str = "ULTRAHEAVY"
+THIN = "THIN"
+ULTRALIGHT = "ULTRALIGHT"
+LIGHT = "LIGHT"
+SEMILIGHT = "SEMILIGHT"
+BOOK = "BOOK"
+MEDIUM = "MEDIUM"
+SEMIBOLD = "SEMIBOLD"
+ULTRABOLD = "ULTRABOLD"
+HEAVY = "HEAVY"
+ULTRAHEAVY = "ULTRAHEAVY"
 
 RESAMPLING_ALGORITHMS = {
     "nearest": Resampling.NEAREST,
@@ -119,79 +122,80 @@ RESAMPLING_ALGORITHMS = {
 }
 
 # Geometry: directions
-ORIGIN: np.ndarray = np.array((0.0, 0.0, 0.0))
+ORIGIN: Vector3 = np.array((0.0, 0.0, 0.0))
 """The center of the coordinate system."""
 
-UP: np.ndarray = np.array((0.0, 1.0, 0.0))
+UP: Vector3 = np.array((0.0, 1.0, 0.0))
 """One unit step in the positive Y direction."""
 
-DOWN: np.ndarray = np.array((0.0, -1.0, 0.0))
+DOWN: Vector3 = np.array((0.0, -1.0, 0.0))
 """One unit step in the negative Y direction."""
 
-RIGHT: np.ndarray = np.array((1.0, 0.0, 0.0))
+RIGHT: Vector3 = np.array((1.0, 0.0, 0.0))
 """One unit step in the positive X direction."""
 
-LEFT: np.ndarray = np.array((-1.0, 0.0, 0.0))
+LEFT: Vector3 = np.array((-1.0, 0.0, 0.0))
 """One unit step in the negative X direction."""
 
-IN: np.ndarray = np.array((0.0, 0.0, -1.0))
+IN: Vector3 = np.array((0.0, 0.0, -1.0))
 """One unit step in the negative Z direction."""
 
-OUT: np.ndarray = np.array((0.0, 0.0, 1.0))
+OUT: Vector3 = np.array((0.0, 0.0, 1.0))
 """One unit step in the positive Z direction."""
 
 # Geometry: axes
-X_AXIS: np.ndarray = np.array((1.0, 0.0, 0.0))
-Y_AXIS: np.ndarray = np.array((0.0, 1.0, 0.0))
-Z_AXIS: np.ndarray = np.array((0.0, 0.0, 1.0))
+X_AXIS: Vector3 = np.array((1.0, 0.0, 0.0))
+Y_AXIS: Vector3 = np.array((0.0, 1.0, 0.0))
+Z_AXIS: Vector3 = np.array((0.0, 0.0, 1.0))
 
 # Geometry: useful abbreviations for diagonals
-UL: np.ndarray = UP + LEFT
+UL: Vector3 = UP + LEFT
 """One step up plus one step left."""
 
-UR: np.ndarray = UP + RIGHT
+UR: Vector3 = UP + RIGHT
 """One step up plus one step right."""
 
-DL: np.ndarray = DOWN + LEFT
+DL: Vector3 = DOWN + LEFT
 """One step down plus one step left."""
 
-DR: np.ndarray = DOWN + RIGHT
+DR: Vector3 = DOWN + RIGHT
 """One step down plus one step right."""
 
 # Geometry
-START_X: int = 30
-START_Y: int = 20
-DEFAULT_DOT_RADIUS: float = 0.08
-DEFAULT_SMALL_DOT_RADIUS: float = 0.04
-DEFAULT_DASH_LENGTH: float = 0.05
-DEFAULT_ARROW_TIP_LENGTH: float = 0.35
+START_X = 30
+START_Y = 20
+DEFAULT_DOT_RADIUS = 0.08
+DEFAULT_SMALL_DOT_RADIUS = 0.04
+DEFAULT_DASH_LENGTH = 0.05
+DEFAULT_ARROW_TIP_LENGTH = 0.35
 
 # Default buffers (padding)
-SMALL_BUFF: float = 0.1
-MED_SMALL_BUFF: float = 0.25
-MED_LARGE_BUFF: float = 0.5
-LARGE_BUFF: float = 1
-DEFAULT_MOBJECT_TO_EDGE_BUFFER: float = MED_LARGE_BUFF
-DEFAULT_MOBJECT_TO_MOBJECT_BUFFER: float = MED_SMALL_BUFF
+SMALL_BUFF = 0.1
+MED_SMALL_BUFF = 0.25
+MED_LARGE_BUFF = 0.5
+LARGE_BUFF = 1
+DEFAULT_MOBJECT_TO_EDGE_BUFFER = MED_LARGE_BUFF
+DEFAULT_MOBJECT_TO_MOBJECT_BUFFER = MED_SMALL_BUFF
 
 # Times in seconds
-DEFAULT_POINTWISE_FUNCTION_RUN_TIME: float = 3.0
-DEFAULT_WAIT_TIME: float = 1.0
+DEFAULT_POINTWISE_FUNCTION_RUN_TIME = 3.0
+DEFAULT_WAIT_TIME = 1.0
 
 # Misc
-DEFAULT_POINT_DENSITY_2D: int = 25
-DEFAULT_POINT_DENSITY_1D: int = 10
-DEFAULT_STROKE_WIDTH: int = 4
-DEFAULT_FONT_SIZE: float = 48
+DEFAULT_POINT_DENSITY_2D = 25
+DEFAULT_POINT_DENSITY_1D = 10
+DEFAULT_STROKE_WIDTH = 4
+DEFAULT_FONT_SIZE = 48
+SCALE_FACTOR_PER_FONT_POINT = 1 / 960
 
 # Mathematical constants
-PI: float = np.pi
+PI = np.pi
 """The ratio of the circumference of a circle to its diameter."""
 
-TAU: float = 2 * PI
+TAU = 2 * PI
 """The ratio of the circumference of a circle to its radius."""
 
-DEGREES: float = TAU / 360
+DEGREES = TAU / 360
 """The exchange rate between radians and degrees."""
 
 # Video qualities
@@ -234,7 +238,7 @@ QUALITIES: dict[str, dict[str, str | int | None]] = {
     },
 }
 
-DEFAULT_QUALITY: str = "high_quality"
+DEFAULT_QUALITY = "high_quality"
 
 EPILOG = "Made with <3 by Manim Community developers."
 SHIFT_VALUE = 65505

manim/mobject/geometry/__init__.py

@@ -8,6 +8,7 @@ Modules
 
     ~arc
     ~boolean_ops
+    ~labeled
     ~line
     ~polygram
     ~shape_matchers