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

manim/animation/animation.py

@@ -1,6 +1,5 @@
 """Animate mobjects."""
 
-
 from __future__ import annotations
 
 from manim.mobject.opengl.opengl_mobject import OpenGLMobject
@@ -18,6 +17,8 @@ __all__ = ["Animation", "Wait", "override_animation"]
 from copy import deepcopy
 from typing import TYPE_CHECKING, Callable, Iterable, Sequence
 
+from typing_extensions import Self
+
 if TYPE_CHECKING:
     from manim.scene.scene import Scene
 
@@ -112,7 +113,7 @@ class Animation:
         *args,
         use_override=True,
         **kwargs,
-    ):
+    ) -> Self:
         if isinstance(mobject, Mobject) and use_override:
             func = mobject.animation_override_for(cls)
             if func is not None:
@@ -191,6 +192,11 @@ class Animation:
         method.
 
         """
+        if self.run_time <= 0:
+            raise ValueError(
+                f"{self} has a run_time of <= 0 seconds, this cannot be rendered correctly. "
+                "Please set the run_time to be positive"
+            )
         self.starting_mobject = self.create_starting_mobject()
         if self.suspend_mobject_updating:
             # All calls to self.mobject's internal updaters
@@ -398,6 +404,7 @@ class Animation:
         self.run_time = run_time
         return self
 
+    # TODO: is this getter even necessary?
     def get_run_time(self) -> float:
         """Get the run time of the animation.
 

manim/animation/composition.py

@@ -1,26 +1,25 @@
 """Tools for displaying multiple animations at once."""
 
-
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Callable, Sequence
+import types
+from typing import TYPE_CHECKING, Callable, Iterable, Sequence
 
 import numpy as np
 
+from manim._config import config
+from manim.animation.animation import Animation, prepare_animation
+from manim.constants import RendererType
+from manim.mobject.mobject import Group, Mobject
 from manim.mobject.opengl.opengl_mobject import OpenGLGroup
-
-from .._config import config
-from ..animation.animation import Animation, prepare_animation
-from ..constants import RendererType
-from ..mobject.mobject import Group, Mobject
-from ..scene.scene import Scene
-from ..utils.iterables import remove_list_redundancies
-from ..utils.rate_functions import linear
+from manim.scene.scene import Scene
+from manim.utils.iterables import remove_list_redundancies
+from manim.utils.parameter_parsing import flatten_iterable_parameters
+from manim.utils.rate_functions import linear
 
 if TYPE_CHECKING:
     from manim.mobject.opengl.opengl_vectorized_mobject import OpenGLVGroup
-
-    from ..mobject.types.vectorized_mobject import VGroup
+    from manim.mobject.types.vectorized_mobject import VGroup
 
 __all__ = ["AnimationGroup", "Succession", "LaggedStart", "LaggedStartMap"]
 
@@ -54,14 +53,15 @@ class AnimationGroup(Animation):
 
     def __init__(
         self,
-        *animations: Animation,
+        *animations: Animation | Iterable[Animation] | types.GeneratorType[Animation],
         group: Group | VGroup | OpenGLGroup | OpenGLVGroup = None,
         run_time: float | None = None,
         rate_func: Callable[[float], float] = linear,
         lag_ratio: float = 0,
         **kwargs,
     ) -> None:
-        self.animations = [prepare_animation(anim) for anim in animations]
+        arg_anim = flatten_iterable_parameters(animations)
+        self.animations = [prepare_animation(anim) for anim in arg_anim]
         self.rate_func = rate_func
         self.group = group
         if self.group is None:
@@ -81,6 +81,17 @@ class AnimationGroup(Animation):
         return list(self.group)
 
     def begin(self) -> None:
+        if self.run_time <= 0:
+            tmp = (
+                "Please set the run_time to be positive"
+                if len(self.animations) != 0
+                else "Please add at least one Animation with positive run_time"
+            )
+            raise ValueError(
+                f"{self} has a run_time of 0 seconds, this cannot be "
+                f"rendered correctly. {tmp}."
+            )
+        self.anim_group_time = 0.0
         if self.suspend_mobject_updating:
             self.group.suspend_updating()
         for anim in self.animations:
@@ -91,8 +102,9 @@ class AnimationGroup(Animation):
             anim._setup_scene(scene)
 
     def finish(self) -> None:
-        for anim in self.animations:
-            anim.finish()
+        self.interpolate(1)
+        self.anims_begun[:] = True
+        self.anims_finished[:] = True
         if self.suspend_mobject_updating:
             self.group.resume_updating()
 
@@ -104,7 +116,9 @@ class AnimationGroup(Animation):
             anim.clean_up_from_scene(scene)
 
     def update_mobjects(self, dt: float) -> None:
-        for anim in self.animations:
+        for anim in self.anims_with_timings["anim"][
+            self.anims_begun & ~self.anims_finished
+        ]:
             anim.update_mobjects(dt)
 
     def init_run_time(self, run_time) -> float:
@@ -121,22 +135,30 @@ class AnimationGroup(Animation):
             The duration of the animation in seconds.
         """
         self.build_animations_with_timings()
-        if self.anims_with_timings:
-            self.max_end_time = np.max([awt[2] for awt in self.anims_with_timings])
-        else:
-            self.max_end_time = 0
+        # Note: if lag_ratio < 1, then not necessarily the final animation's
+        # end time will be the max end time! Therefore we must calculate the
+        # maximum over all the end times, and not just take the last one.
+        # Example: if you want to play 2 animations of 10s and 1s with a
+        # lag_ratio of 0.1, the 1st one will end at t=10 and the 2nd one will
+        # end at t=2, so the AnimationGroup will end at t=10.
+        self.max_end_time = max(self.anims_with_timings["end"], default=0)
         return self.max_end_time if run_time is None else run_time
 
     def build_animations_with_timings(self) -> None:
         """Creates a list of triplets of the form (anim, start_time, end_time)."""
-        self.anims_with_timings = []
-        curr_time: float = 0
-        for anim in self.animations:
-            start_time: float = curr_time
-            end_time: float = start_time + anim.get_run_time()
-            self.anims_with_timings.append((anim, start_time, end_time))
-            # Start time of next animation is based on the lag_ratio
-            curr_time = (1 - self.lag_ratio) * start_time + self.lag_ratio * end_time
+        run_times = np.array([anim.run_time for anim in self.animations])
+        num_animations = run_times.shape[0]
+        dtype = [("anim", "O"), ("start", "f8"), ("end", "f8")]
+        self.anims_with_timings = np.zeros(num_animations, dtype=dtype)
+        self.anims_begun = np.zeros(num_animations, dtype=bool)
+        self.anims_finished = np.zeros(num_animations, dtype=bool)
+        if num_animations == 0:
+            return
+
+        lags = run_times[:-1] * self.lag_ratio
+        self.anims_with_timings["anim"] = self.animations
+        self.anims_with_timings["start"][1:] = np.add.accumulate(lags)
+        self.anims_with_timings["end"] = self.anims_with_timings["start"] + run_times
 
     def interpolate(self, alpha: float) -> None:
         # Note, if the run_time of AnimationGroup has been
@@ -144,14 +166,30 @@ class AnimationGroup(Animation):
         # times might not correspond to actual times,
         # e.g. of the surrounding scene.  Instead they'd
         # be a rescaled version.  But that's okay!
-        time = self.rate_func(alpha) * self.max_end_time
-        for anim, start_time, end_time in self.anims_with_timings:
-            anim_time = end_time - start_time
-            if anim_time == 0:
-                sub_alpha = 0
-            else:
-                sub_alpha = np.clip((time - start_time) / anim_time, 0, 1)
-            anim.interpolate(sub_alpha)
+        anim_group_time = self.rate_func(alpha) * self.max_end_time
+        time_goes_back = anim_group_time < self.anim_group_time
+
+        # Only update ongoing animations
+        awt = self.anims_with_timings
+        new_begun = anim_group_time >= awt["start"]
+        new_finished = anim_group_time > awt["end"]
+        to_update = awt[
+            (self.anims_begun | new_begun) & (~self.anims_finished | ~new_finished)
+        ]
+
+        run_times = to_update["end"] - to_update["start"]
+        sub_alphas = (anim_group_time - to_update["start"]) / run_times
+        if time_goes_back:
+            sub_alphas[sub_alphas < 0] = 0
+        else:
+            sub_alphas[sub_alphas > 1] = 1
+
+        for anim_to_update, sub_alpha in zip(to_update["anim"], sub_alphas):
+            anim_to_update.interpolate(sub_alpha)
+
+        self.anim_group_time = anim_group_time
+        self.anims_begun = new_begun
+        self.anims_finished = new_finished
 
 
 class Succession(AnimationGroup):
@@ -226,8 +264,8 @@ class Succession(AnimationGroup):
             self.active_animation = self.animations[index]
             self.active_animation._setup_scene(self.scene)
             self.active_animation.begin()
-            self.active_start_time = self.anims_with_timings[index][1]
-            self.active_end_time = self.anims_with_timings[index][2]
+            self.active_start_time = self.anims_with_timings[index]["start"]
+            self.active_end_time = self.anims_with_timings[index]["end"]
 
     def next_animation(self) -> None:
         """Proceeds to the next animation.
@@ -244,7 +282,7 @@ class Succession(AnimationGroup):
             self.next_animation()
         if self.active_animation is not None and self.active_start_time is not None:
             elapsed = current_time - self.active_start_time
-            active_run_time = self.active_animation.get_run_time()
+            active_run_time = self.active_animation.run_time
             subalpha = elapsed / active_run_time if active_run_time != 0.0 else 1.0
             self.active_animation.interpolate(subalpha)
 

manim/animation/creation.py

@@ -456,7 +456,7 @@ class SpiralIn(Animation):
         fade_in_fraction=0.3,
         **kwargs,
     ) -> None:
-        self.shapes = shapes
+        self.shapes = shapes.copy()
         self.scale_factor = scale_factor
         self.shape_center = shapes.get_center()
         self.fade_in_fraction = fade_in_fraction
@@ -473,15 +473,21 @@ class SpiralIn(Animation):
 
     def interpolate_mobject(self, alpha: float) -> None:
         alpha = self.rate_func(alpha)
-        for shape in self.shapes:
+        for original_shape, shape in zip(self.shapes, self.mobject):
             shape.restore()
-            shape.save_state()
-            opacity = shape.get_fill_opacity()
-            new_opacity = min(opacity, alpha * opacity / self.fade_in_fraction)
+            fill_opacity = original_shape.get_fill_opacity()
+            stroke_opacity = original_shape.get_stroke_opacity()
+            new_fill_opacity = min(
+                fill_opacity, alpha * fill_opacity / self.fade_in_fraction
+            )
+            new_stroke_opacity = min(
+                stroke_opacity, alpha * stroke_opacity / self.fade_in_fraction
+            )
             shape.shift((shape.final_position - shape.initial_position) * alpha)
             shape.rotate(TAU * alpha, about_point=self.shape_center)
             shape.rotate(-TAU * alpha, about_point=shape.get_center_of_mass())
-            shape.set_opacity(new_opacity)
+            shape.set_fill(opacity=new_fill_opacity)
+            shape.set_stroke(opacity=new_stroke_opacity)
 
 
 class ShowIncreasingSubsets(Animation):

manim/animation/fading.py

@@ -12,7 +12,6 @@
 
 """
 
-
 from __future__ import annotations
 
 __all__ = [

manim/animation/indication.py

@@ -31,7 +31,6 @@ __all__ = [
     "Flash",
     "ShowPassingFlash",
     "ShowPassingFlashWithThinningStrokeWidth",
-    "ShowCreationThenFadeOut",
     "ApplyWave",
     "Circumscribe",
     "Wiggle",
@@ -131,7 +130,7 @@ class Indicate(Transform):
     color
         The color the mobject temporally takes.
     rate_func
-        The function definig the animation progress at every point in time.
+        The function defining the animation progress at every point in time.
     kwargs
         Additional arguments to be passed to the :class:`~.Succession` constructor
 
@@ -148,7 +147,7 @@ class Indicate(Transform):
 
     def __init__(
         self,
-        mobject: "Mobject",
+        mobject: Mobject,
         scale_factor: float = 1.2,
         color: str = YELLOW,
         rate_func: Callable[[float, Optional[float]], np.ndarray] = there_and_back,
@@ -158,7 +157,7 @@ class Indicate(Transform):
         self.scale_factor = scale_factor
         super().__init__(mobject, rate_func=rate_func, **kwargs)
 
-    def create_target(self) -> "Mobject":
+    def create_target(self) -> Mobject:
         target = self.mobject.copy()
         target.scale(self.scale_factor)
         target.set_color(self.color)
@@ -342,16 +341,6 @@ class ShowPassingFlashWithThinningStrokeWidth(AnimationGroup):
         )
 
 
-@deprecated(
-    since="v0.15.0",
-    until="v0.16.0",
-    message="Use Create then FadeOut to achieve this effect.",
-)
-class ShowCreationThenFadeOut(Succession):
-    def __init__(self, mobject: "Mobject", remover: bool = True, **kwargs) -> None:
-        super().__init__(Create(mobject), FadeOut(mobject), remover=remover, **kwargs)
-
-
 class ApplyWave(Homotopy):
     """Send a wave through the Mobject distorting it temporarily.
 
@@ -397,7 +386,7 @@ class ApplyWave(Homotopy):
 
     def __init__(
         self,
-        mobject: "Mobject",
+        mobject: Mobject,
         direction: np.ndarray = UP,
         amplitude: float = 0.2,
         wave_func: Callable[[float], float] = smooth,
@@ -415,7 +404,7 @@ class ApplyWave(Homotopy):
             # This wave is build up as follows:
             # The time is split into 2*ripples phases. In every phase the amplitude
             # either rises to one or goes down to zero. Consecutive ripples will have
-            # their amplitudes in oppising directions (first ripple from 0 to 1 to 0,
+            # their amplitudes in opposing directions (first ripple from 0 to 1 to 0,
             # second from 0 to -1 to 0 and so on). This is how two ripples would be
             # divided into phases:
 
@@ -454,7 +443,7 @@ class ApplyWave(Homotopy):
                 return wave_func(t * phases)
             elif phase == phases - 1:
                 # last ripple. Rising or falling depending on the number of ripples
-                # The (ripples % 2)-term is used to make this destinction.
+                # The (ripples % 2)-term is used to make this distinction.
                 t -= phase / phases  # Time relative to the phase
                 return (1 - wave_func(t * phases)) * (2 * (ripples % 2) - 1)
             else:
@@ -516,7 +505,7 @@ class Wiggle(Animation):
 
     def __init__(
         self,
-        mobject: "Mobject",
+        mobject: Mobject,
         scale_value: float = 1.1,
         rotation_angle: float = 0.01 * TAU,
         n_wiggles: int = 6,
@@ -544,8 +533,8 @@ class Wiggle(Animation):
 
     def interpolate_submobject(
         self,
-        submobject: "Mobject",
-        starting_submobject: "Mobject",
+        submobject: Mobject,
+        starting_submobject: Mobject,
         alpha: float,
     ) -> None:
         submobject.points[:, :] = starting_submobject.points
@@ -567,7 +556,7 @@ class Circumscribe(Succession):
     mobject
         The mobject to be circumscribed.
     shape
-        The shape with which to surrond the given mobject. Should be either
+        The shape with which to surround the given mobject. Should be either
         :class:`~.Rectangle` or :class:`~.Circle`
     fade_in
         Whether to make the surrounding shape to fade in. It will be drawn otherwise.

manim/animation/movement.py

@@ -136,8 +136,7 @@ class PhaseFlow(Animation):
 
 class MoveAlongPath(Animation):
     """Make one mobject move along the path of another mobject.
-    Example
-    --------
+
     .. manim:: MoveAlongPathExample
 
         class MoveAlongPathExample(Scene):

manim/animation/rotation.py

@@ -59,7 +59,7 @@ class Rotate(Transform):
     about_point
         The rotation center.
     about_edge
-        If ``about_point``is ``None``, this argument specifies
+        If ``about_point`` is ``None``, this argument specifies
         the direction of the bounding box point to be taken as
         the rotation center.
 

manim/animation/specialized.py

@@ -84,7 +84,7 @@ class Broadcast(LaggedStart):
 
             mob.move_to(self.focal_point)
             mob.save_state()
-            mob.set_width(self.initial_width)
+            mob.set(width=self.initial_width)
 
             if fill_o:
                 mob.set_opacity(self.initial_opacity)

manim/animation/speedmodifier.py

@@ -4,15 +4,20 @@ from __future__ import annotations
 
 import inspect
 import types
-from typing import Callable
+from typing import TYPE_CHECKING, Callable
 
 from numpy import piecewise
 
 from ..animation.animation import Animation, Wait, prepare_animation
 from ..animation.composition import AnimationGroup
-from ..mobject.mobject import Mobject, Updater, _AnimationBuilder
+from ..mobject.mobject import Mobject, _AnimationBuilder
 from ..scene.scene import Scene
 
+if TYPE_CHECKING:
+    from ..mobject.mobject import Updater
+
+__all__ = ["ChangeSpeed"]
+
 
 class ChangeSpeed(Animation):
     """Modifies the speed of passed animation.

manim/animation/transform_matching_parts.py

@@ -225,7 +225,7 @@ class TransformMatchingShapes(TransformMatchingAbstractBase):
     def get_mobject_key(mobject: Mobject) -> int:
         mobject.save_state()
         mobject.center()
-        mobject.set_height(1)
+        mobject.set(height=1)
         result = hash(np.round(mobject.points, 3).tobytes())
         mobject.restore()
         return result

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"]
@@ -37,6 +36,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.
 
@@ -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/cfg/group.py

@@ -5,13 +5,12 @@ cfg``. Here you can specify options, subcommands, and subgroups for the cfg
 group.
 
 """
+
 from __future__ import annotations
 
-import os
 from ast import literal_eval
 from pathlib import Path
 
-import click
 import cloup
 from rich.errors import StyleSyntaxError
 from rich.style import Style
@@ -28,6 +27,17 @@ If left empty, the default colour will be used.[/red]
 """
 RICH_NON_STYLE_ENTRIES: 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.
@@ -123,21 +133,21 @@ def replace_keys(default: dict) -> dict:
     epilog=EPILOG,
     help="Manages Manim configuration files.",
 )
-@click.pass_context
+@cloup.pass_context
 def cfg(ctx):
     """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)
+@cloup.option("-o", "--open", "openfile", is_flag=True)
 def write(level: str = None, openfile: bool = False) -> None:
     config_paths = config_file_paths()
     console.print(
@@ -258,8 +268,8 @@ def show():
 
 
 @cfg.command(context_settings=cli_ctx_settings)
-@click.option("-d", "--directory", default=Path.cwd())
-@click.pass_context
+@cloup.option("-d", "--directory", default=Path.cwd())
+@cloup.pass_context
 def export(ctx, directory):
     directory_path = Path(directory)
     if directory_path.absolute == Path.cwd().absolute:

manim/cli/checkhealth/checks.py

@@ -10,6 +10,8 @@ from typing import Callable
 
 from ..._config import config
 
+__all__ = ["HEALTH_CHECKS"]
+
 HEALTH_CHECKS = []
 
 

manim/cli/checkhealth/commands.py

@@ -12,6 +12,8 @@ import cloup
 
 from .checks import HEALTH_CHECKS
 
+__all__ = ["checkhealth"]
+
 
 @cloup.command(
     context_settings=None,

manim/cli/default_group.py

@@ -1,10 +1,18 @@
-"""DefaultGroup allows a subcommand to act as the main command
+"""``DefaultGroup`` allows a subcommand to act as the main command.
 
 In particular, this class is what allows ``manim`` to act as ``manim render``.
+
+.. note::
+    This is a vendored version of https://github.com/click-contrib/click-default-group/
+    under the BSD 3-Clause "New" or "Revised" License.
+
+    This library isn't used as a dependency as we need to inherit from ``cloup.Group`` instead
+    of ``click.Group``.
 """
-import cloup
 
-from .. import logger
+import warnings
+
+import cloup
 
 __all__ = ["DefaultGroup"]
 
@@ -54,8 +62,8 @@ class DefaultGroup(cloup.Group):
         decorator = super().command(*args, **kwargs)
         if not default:
             return decorator
-        logger.log(
-            "Use default param of DefaultGroup or " "set_default_command() instead",
+        warnings.warn(
+            "Use default param of DefaultGroup or set_default_command() instead",
             DeprecationWarning,
         )
 

manim/cli/init/commands.py

@@ -5,6 +5,7 @@ init``. Here you can specify options, subcommands, and subgroups for the init
 group.
 
 """
+
 from __future__ import annotations
 
 import configparser
@@ -30,6 +31,8 @@ CFG_DEFAULTS = {
     "resolution": (854, 480),
 }
 
+__all__ = ["select_resolution", "update_cfg", "project", "scene"]
+
 
 def select_resolution():
     """Prompts input of type click.Choice from user. Presents options from QUALITIES constant.
@@ -47,7 +50,7 @@ def select_resolution():
     resolution_options.pop()
     choice = click.prompt(
         "\nSelect resolution:\n",
-        type=click.Choice([f"{i[0]}p" for i in resolution_options]),
+        type=cloup.Choice([f"{i[0]}p" for i in resolution_options]),
         show_default=False,
         default="480p",
     )

manim/cli/plugins/commands.py

@@ -5,6 +5,7 @@ plugin``. Here you can specify options, subcommands, and subgroups for the plugi
 group.
 
 """
+
 from __future__ import annotations
 
 import cloup
@@ -12,6 +13,8 @@ import cloup
 from ...constants import CONTEXT_SETTINGS, EPILOG
 from ...plugins.plugins_flags import list_plugins
 
+__all__ = ["plugins"]
+
 
 @cloup.command(
     context_settings=CONTEXT_SETTINGS,