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

manim/__init__.py

@@ -46,6 +46,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

@@ -7,6 +7,7 @@ import cloup
 
 from . import __version__, cli_ctx_settings, console
 from .cli.cfg.group import cfg
+from .cli.checkhealth.commands import checkhealth
 from .cli.default_group import DefaultGroup
 from .cli.init.commands import init
 from .cli.new.group import new
@@ -48,6 +49,7 @@ def main(ctx):
     pass
 
 
+main.add_command(checkhealth)
 main.add_command(cfg)
 main.add_command(plugins)
 main.add_command(init)

manim/_config/__init__.py

@@ -20,7 +20,6 @@ __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.

manim/_config/logger_utils.py

@@ -26,6 +26,7 @@ from rich.theme import Theme
 
 if TYPE_CHECKING:
     from pathlib import Path
+
 HIGHLIGHTED_KEYWORDS = [  # these keywords are highlighted specially
     "Played",
     "animations",

manim/_config/utils.py

@@ -23,13 +23,13 @@ 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 ..constants import RendererType
+from ..typing import StrPath
+from ..utils.color import ManimColor
 from ..utils.tex import TexTemplate, TexTemplateFromFile
-from ..utils.tex_templates import TexTemplateLibrary
 
 
 def config_file_paths() -> list[Path]:
@@ -76,7 +76,7 @@ def config_file_paths() -> list[Path]:
 
 
 def make_config_parser(
-    custom_file: str | os.PathLike | None = None,
+    custom_file: StrPath | None = None,
 ) -> configparser.ConfigParser:
     """Make a :class:`ConfigParser` object and load any ``.cfg`` files.
 
@@ -309,6 +309,7 @@ class ManimConfig(MutableMapping):
         "write_to_movie",
         "zero_pad",
         "force_window",
+        "no_latex_cleanup",
     }
 
     def __init__(self) -> None:
@@ -580,6 +581,7 @@ class ManimConfig(MutableMapping):
             "use_projection_stroke_shaders",
             "enable_wireframe",
             "force_window",
+            "no_latex_cleanup",
         ]:
             setattr(self, key, parser["CLI"].getboolean(key, fallback=False))
 
@@ -756,6 +758,7 @@ class ManimConfig(MutableMapping):
             "enable_wireframe",
             "force_window",
             "dry_run",
+            "no_latex_cleanup",
         ]:
             if hasattr(args, key):
                 attr = getattr(args, key)
@@ -960,6 +963,12 @@ class ManimConfig(MutableMapping):
         doc="Set to force window when using the opengl renderer",
     )
 
+    no_latex_cleanup = property(
+        lambda self: self._d["no_latex_cleanup"],
+        lambda self, val: self._set_boolean("no_latex_cleanup", val),
+        doc="Prevents deletion of .aux, .dvi, and .log files produced by Tex and MathTex.",
+    )
+
     @property
     def verbosity(self):
         """Logger verbosity; "DEBUG", "INFO", "WARNING", "ERROR", or "CRITICAL" (-v)."""
@@ -1096,7 +1105,7 @@ class ManimConfig(MutableMapping):
 
     background_color = property(
         lambda self: self._d["background_color"],
-        lambda self, val: self._d.__setitem__("background_color", colour.Color(val)),
+        lambda self, val: self._d.__setitem__("background_color", ManimColor(val)),
         doc="Background color of the scene (-c).",
     )
 
@@ -1172,7 +1181,7 @@ class ManimConfig(MutableMapping):
         keys = ["pixel_width", "pixel_height", "frame_rate"]
         q = {k: self[k] for k in keys}
         for qual in constants.QUALITIES:
-            if all([q[k] == constants.QUALITIES[qual][k] for k in keys]):
+            if all(q[k] == constants.QUALITIES[qual][k] for k in keys):
                 return qual
         return None
 

manim/animation/changing.py

@@ -6,12 +6,16 @@ __all__ = ["AnimatedBoundary", "TracedPath"]
 
 from typing import Callable
 
-from colour import Color
-
-from manim._config import config
 from manim.mobject.opengl.opengl_compatibility import ConvertToOpenGL
 from manim.mobject.types.vectorized_mobject import VGroup, VMobject
-from manim.utils.color import BLUE_B, BLUE_D, BLUE_E, GREY_BROWN, WHITE
+from manim.utils.color import (
+    BLUE_B,
+    BLUE_D,
+    BLUE_E,
+    GREY_BROWN,
+    WHITE,
+    ParsableManimColor,
+)
 from manim.utils.rate_functions import smooth
 
 
@@ -140,7 +144,7 @@ class TracedPath(VMobject, metaclass=ConvertToOpenGL):
         self,
         traced_point_func: Callable,
         stroke_width: float = 2,
-        stroke_color: Color = WHITE,
+        stroke_color: ParsableManimColor | None = WHITE,
         dissipating_time: float | None = None,
         **kwargs,
     ):

manim/animation/creation.py

@@ -77,13 +77,13 @@ import itertools as it
 from typing import TYPE_CHECKING, Callable, Iterable, Sequence
 
 import numpy as np
-from colour import Color
 
 if TYPE_CHECKING:
     from manim.mobject.text.text_mobject import Text
 
 from manim.mobject.opengl.opengl_surface import OpenGLSurface
 from manim.mobject.opengl.opengl_vectorized_mobject import OpenGLVMobject
+from manim.utils.color import ManimColor
 
 from .. import config
 from ..animation.animation import Animation
@@ -92,7 +92,7 @@ from ..constants import TAU
 from ..mobject.mobject import Group, Mobject
 from ..mobject.types.vectorized_mobject import VMobject
 from ..utils.bezier import integer_interpolate
-from ..utils.rate_functions import double_smooth, linear, smooth
+from ..utils.rate_functions import double_smooth, linear
 
 
 class ShowPartial(Animation):
@@ -259,7 +259,7 @@ class DrawBorderThenFill(Animation):
             sm.set_stroke(color=self.get_stroke_color(sm), width=self.stroke_width)
         return outline
 
-    def get_stroke_color(self, vmobject: VMobject | OpenGLVMobject) -> Color:
+    def get_stroke_color(self, vmobject: VMobject | OpenGLVMobject) -> ManimColor:
         if self.stroke_color:
             return self.stroke_color
         elif vmobject.get_stroke_width() > 0:
@@ -563,6 +563,11 @@ class AddTextLetterByLetter(ShowIncreasingSubsets):
         **kwargs,
     ) -> None:
         self.time_per_char = time_per_char
+        # Check for empty text using family_members_with_points()
+        if not text.family_members_with_points():
+            raise ValueError(
+                f"The text mobject {text} does not seem to contain any characters."
+            )
         if run_time is None:
             # minimum time per character is 1/frame_rate, otherwise
             # the animation does not finish.

manim/animation/indication.py

@@ -40,12 +40,12 @@ __all__ = [
 from typing import Callable, Iterable, Optional, Tuple, Type, Union
 
 import numpy as np
-from colour import Color
 
 from manim.mobject.geometry.arc import Circle, Dot
 from manim.mobject.geometry.line import Line
 from manim.mobject.geometry.polygram import Rectangle
 from manim.mobject.geometry.shape_matchers import SurroundingRectangle
+from manim.scene.scene import Scene
 
 from .. import config
 from ..animation.animation import Animation
@@ -58,7 +58,7 @@ from ..constants import *
 from ..mobject.mobject import Mobject
 from ..mobject.types.vectorized_mobject import VGroup, VMobject
 from ..utils.bezier import interpolate, inverse_interpolate
-from ..utils.color import GREY, YELLOW
+from ..utils.color import GREY, YELLOW, ParsableManimColor
 from ..utils.deprecation import deprecated
 from ..utils.rate_functions import smooth, there_and_back, wiggle
 from ..utils.space_ops import normalize
@@ -314,7 +314,7 @@ class ShowPassingFlash(ShowPartial):
         lower = max(lower, 0)
         return (lower, upper)
 
-    def clean_up_from_scene(self, scene: "Scene") -> None:
+    def clean_up_from_scene(self, scene: Scene) -> None:
         super().clean_up_from_scene(scene)
         for submob, start in self.get_all_families_zipped():
             submob.pointwise_become_partial(start, 0, 1)
@@ -609,7 +609,7 @@ class Circumscribe(Succession):
         fade_out=False,
         time_width=0.3,
         buff: float = SMALL_BUFF,
-        color: Color = YELLOW,
+        color: ParsableManimColor = YELLOW,
         run_time=1,
         stroke_width=DEFAULT_STROKE_WIDTH,
         **kwargs

manim/animation/speedmodifier.py

@@ -2,13 +2,12 @@
 
 from __future__ import annotations
 
+import inspect
 import types
 from typing import Callable
 
 from numpy import piecewise
 
-from manim.utils.simple_functions import get_parameters
-
 from ..animation.animation import Animation, Wait, prepare_animation
 from ..animation.composition import AnimationGroup
 from ..mobject.mobject import Mobject, Updater, _AnimationBuilder
@@ -260,8 +259,7 @@ class ChangeSpeed(Animation):
         :class:`.ChangeSpeed`
         :meth:`.Mobject.add_updater`
         """
-        parameters = get_parameters(update_function)
-        if "dt" in parameters:
+        if "dt" in inspect.signature(update_function).parameters:
             mobject.add_updater(
                 lambda mob, dt: update_function(
                     mob, ChangeSpeed.dt if ChangeSpeed.is_changing_dt else dt

manim/animation/updaters/mobject_update_utils.py

@@ -15,21 +15,26 @@ __all__ = [
 
 
 import inspect
+from typing import TYPE_CHECKING, Callable
 
 import numpy as np
 
 from manim.constants import DEGREES, RIGHT
 from manim.mobject.mobject import Mobject
 from manim.opengl import OpenGLMobject
+from manim.utils.space_ops import normalize
 
+if TYPE_CHECKING:
+    from manim.animation.animation import Animation
 
-def assert_is_mobject_method(method):
+
+def assert_is_mobject_method(method: Callable) -> None:
     assert inspect.ismethod(method)
     mobject = method.__self__
     assert isinstance(mobject, (Mobject, OpenGLMobject))
 
 
-def always(method, *args, **kwargs):
+def always(method: Callable, *args, **kwargs) -> Mobject:
     assert_is_mobject_method(method)
     mobject = method.__self__
     func = method.__func__
@@ -37,7 +42,7 @@ def always(method, *args, **kwargs):
     return mobject
 
 
-def f_always(method, *arg_generators, **kwargs):
+def f_always(method: Callable[[Mobject], None], *arg_generators, **kwargs) -> Mobject:
     """
     More functional version of always, where instead
     of taking in args, it takes in functions which output
@@ -55,42 +60,155 @@ def f_always(method, *arg_generators, **kwargs):
     return mobject
 
 
-def always_redraw(func):
+def always_redraw(func: Callable[[], Mobject]) -> Mobject:
+    """Redraw the mobject constructed by a function every frame.
+
+    This function returns a mobject with an attached updater that
+    continuously regenerates the mobject according to the
+    specified function.
+
+    Parameters
+    ----------
+    func
+        A function without (required) input arguments that returns
+        a mobject.
+
+    Examples
+    --------
+
+    .. manim:: TangentAnimation
+
+        class TangentAnimation(Scene):
+            def construct(self):
+                ax = Axes()
+                sine = ax.plot(np.sin, color=RED)
+                alpha = ValueTracker(0)
+                point = always_redraw(
+                    lambda: Dot(
+                        sine.point_from_proportion(alpha.get_value()),
+                        color=BLUE
+                    )
+                )
+                tangent = always_redraw(
+                    lambda: TangentLine(
+                        sine,
+                        alpha=alpha.get_value(),
+                        color=YELLOW,
+                        length=4
+                    )
+                )
+                self.add(ax, sine, point, tangent)
+                self.play(alpha.animate.set_value(1), rate_func=linear, run_time=2)
+    """
     mob = func()
-    mob.add_updater(lambda m: mob.become(func()))
+    mob.add_updater(lambda _: mob.become(func()))
     return mob
 
 
-def always_shift(mobject, direction=RIGHT, rate=0.1):
-    def normalize(v):
-        norm = np.linalg.norm(v)
-        if norm == 0:
-            return v
-        return v / norm
-
+def always_shift(
+    mobject: Mobject, direction: np.ndarray[np.float64] = RIGHT, rate: float = 0.1
+) -> Mobject:
+    """A mobject which is continuously shifted along some direction
+    at a certain rate.
+
+    Parameters
+    ----------
+    mobject
+        The mobject to shift.
+    direction
+        The direction to shift. The vector is normalized, the specified magnitude
+        is not relevant.
+    rate
+        Length in Manim units which the mobject travels in one
+        second along the specified direction.
+
+    Examples
+    --------
+
+    .. manim:: ShiftingSquare
+
+        class ShiftingSquare(Scene):
+            def construct(self):
+                sq = Square().set_fill(opacity=1)
+                tri = Triangle()
+                VGroup(sq, tri).arrange(LEFT)
+
+                # construct a square which is continuously
+                # shifted to the right
+                always_shift(sq, RIGHT, rate=5)
+
+                self.add(sq)
+                self.play(tri.animate.set_fill(opacity=1))
+    """
     mobject.add_updater(lambda m, dt: m.shift(dt * rate * normalize(direction)))
     return mobject
 
 
-def always_rotate(mobject, rate=20 * DEGREES, **kwargs):
+def always_rotate(mobject: Mobject, rate: float = 20 * DEGREES, **kwargs) -> Mobject:
+    """A mobject which is continuously rotated at a certain rate.
+
+    Parameters
+    ----------
+    mobject
+        The mobject to be rotated.
+    rate
+        The angle which the mobject is rotated by
+        over one second.
+    kwags
+        Further arguments to be passed to :meth:`.Mobject.rotate`.
+
+    Examples
+    --------
+
+    .. manim:: SpinningTriangle
+
+        class SpinningTriangle(Scene):
+            def construct(self):
+                tri = Triangle().set_fill(opacity=1).set_z_index(2)
+                sq = Square().to_edge(LEFT)
+
+                # will keep spinning while there is an animation going on
+                always_rotate(tri, rate=2*PI, about_point=ORIGIN)
+
+                self.add(tri, sq)
+                self.play(sq.animate.to_edge(RIGHT), rate_func=linear, run_time=1)
+    """
     mobject.add_updater(lambda m, dt: m.rotate(dt * rate, **kwargs))
     return mobject
 
 
-def turn_animation_into_updater(animation, cycle=False, **kwargs):
+def turn_animation_into_updater(
+    animation: Animation, cycle: bool = False, **kwargs
+) -> Mobject:
     """
     Add an updater to the animation's mobject which applies
     the interpolation and update functions of the animation
 
     If cycle is True, this repeats over and over.  Otherwise,
     the updater will be popped upon completion
+
+    Examples
+    --------
+
+    .. manim:: WelcomeToManim
+
+        class WelcomeToManim(Scene):
+            def construct(self):
+                words = Text("Welcome to")
+                banner = ManimBanner().scale(0.5)
+                VGroup(words, banner).arrange(DOWN)
+
+                turn_animation_into_updater(Write(words, run_time=0.9))
+                self.add(words)
+                self.wait(0.5)
+                self.play(banner.expand(), run_time=0.5)
     """
     mobject = animation.mobject
     animation.suspend_mobject_updating = False
     animation.begin()
     animation.total_time = 0
 
-    def update(m, dt):
+    def update(m: Mobject, dt: float):
         run_time = animation.get_run_time()
         time_ratio = animation.total_time / run_time
         if cycle:
@@ -109,5 +227,5 @@ def turn_animation_into_updater(animation, cycle=False, **kwargs):
     return mobject
 
 
-def cycle_animation(animation, **kwargs):
+def cycle_animation(animation: Animation, **kwargs) -> Mobject:
     return turn_animation_into_updater(animation, cycle=True, **kwargs)

manim/camera/camera.py

@@ -9,7 +9,6 @@ import copy
 import itertools as it
 import operator as op
 import pathlib
-import time
 from functools import reduce
 from typing import Any, Callable, Iterable
 
@@ -24,7 +23,7 @@ from ..mobject.mobject import Mobject
 from ..mobject.types.image_mobject import AbstractImageMobject
 from ..mobject.types.point_cloud_mobject import PMobject
 from ..mobject.types.vectorized_mobject import VMobject
-from ..utils.color import color_to_int_rgba
+from ..utils.color import ManimColor, ParsableManimColor, color_to_int_rgba
 from ..utils.family import extract_mobject_family_members
 from ..utils.images import get_full_raster_image_path
 from ..utils.iterables import list_difference_update
@@ -75,6 +74,8 @@ class Camera:
         frame_height: float | None = None,
         frame_width: float | None = None,
         frame_rate: float | None = None,
+        background_color: ParsableManimColor | None = None,
+        background_opacity: float | None = None,
         **kwargs,
     ):
         self.background_image = background_image
@@ -106,9 +107,14 @@ class Camera:
             frame_rate = config["frame_rate"]
         self.frame_rate = frame_rate
 
-        # TODO: change this to not use kwargs.get
-        for attr in ["background_color", "background_opacity"]:
-            setattr(self, f"_{attr}", kwargs.get(attr, config[attr]))
+        if background_color is None:
+            self._background_color = ManimColor.parse(config["background_color"])
+        else:
+            self._background_color = ManimColor.parse(background_color)
+        if background_opacity is None:
+            self._background_opacity = config["background_opacity"]
+        else:
+            self._background_opacity = background_opacity
 
         # This one is in the same boat as the above, but it doesn't have the
         # same name as the corresponding key so it has to be handled on its own
@@ -886,8 +892,10 @@ class Camera:
         thickness: float,
         pixel_array: np.ndarray,
     ):
-        """Displays a PMobject by modifying the Pixel array suitably..
+        """Displays a PMobject by modifying the pixel array suitably.
+
         TODO: Write a description for the rgbas argument.
+
         Parameters
         ----------
         pmobject
@@ -957,7 +965,7 @@ class Camera:
             The Pixel array to put the imagemobject in.
         """
         corner_coords = self.points_to_pixel_coords(image_mobject, image_mobject.points)
-        ul_coords, ur_coords, dl_coords = corner_coords
+        ul_coords, ur_coords, dl_coords, _ = corner_coords
         right_vect = ur_coords - ul_coords
         down_vect = dl_coords - ul_coords
         center_coords = ul_coords + (right_vect + down_vect) / 2
@@ -1122,17 +1130,19 @@ class Camera:
             ],
         )
 
-    def adjusted_thickness(self, thickness: float):
-        """
+    def adjusted_thickness(self, thickness: float) -> float:
+        """Computes the adjusted stroke width for a zoomed camera.
 
         Parameters
         ----------
         thickness
+            The stroke width of a mobject.
 
         Returns
         -------
         float
-
+            The adjusted stroke width that reflects zooming in with
+            the camera.
         """
         # TODO: This seems...unsystematic
         big_sum = op.add(config["pixel_height"], config["pixel_width"])
@@ -1141,7 +1151,8 @@ class Camera:
         return 1 + (thickness - 1) * factor
 
     def get_thickening_nudges(self, thickness: float):
-        """
+        """Determine a list of vectors used to nudge
+        two-dimensional pixel coordinates.
 
         Parameters
         ----------
@@ -1215,13 +1226,16 @@ class Camera:
 # NOTE: The methods of the following class have not been mentioned outside of their definitions.
 # Their DocStrings are not as detailed as preferred.
 class BackgroundColoredVMobjectDisplayer:
+    """Auxiliary class that handles displaying vectorized mobjects with
+    a set background image.
+
+    Parameters
+    ----------
+    camera
+        Camera object to use.
+    """
+
     def __init__(self, camera: Camera):
-        """
-        Parameters
-        ----------
-        camera
-            Camera object to use.
-        """
         self.camera = camera
         self.file_name_to_pixel_array_map = {}
         self.pixel_array = np.array(camera.pixel_array)