Update subclasses

This is likely to be a very bug-prone commit

Author: JasonGrace2282

manim/animation/animation.py

@@ -335,7 +335,7 @@ def interpolate_submobject(
         alpha: float,
     ) -> Animation:
         # Typically implemented by subclass
-        pass
+        raise NotImplementedError()
 
     def get_sub_alpha(self, alpha: float, index: int, num_submobjects: int) -> float:
         """Get the animation progress of any submobjects subanimation.
@@ -554,9 +554,6 @@ def begin(self) -> None:
     def finish(self) -> None:
         pass
 
-    def clean_up_from_scene(self, scene: SceneBuffer) -> None:
-        pass
-
     def update_mobjects(self, dt: float) -> None:
         pass
 

manim/animation/changing.py

@@ -4,9 +4,11 @@
 
 __all__ = ["AnimatedBoundary", "TracedPath"]
 
-from typing import Callable
+from typing import TYPE_CHECKING, Callable
+
+if TYPE_CHECKING:
+    import numpy.typing as npt
 
-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 (
@@ -61,7 +63,7 @@ def __init__(
         ]
         self.add(*self.boundary_copies)
         self.total_time = 0
-        self.add_updater(lambda m, dt: self.update_boundary_copies(dt))
+        self.add_updater(lambda _, dt: self.update_boundary_copies(dt))
 
     def update_boundary_copies(self, dt):
         # Not actual time, but something which passes at
@@ -143,7 +145,9 @@ def construct(self):
 
     def __init__(
         self,
-        traced_point_func: Callable,
+        traced_point_func: Callable[
+            [], npt.NDArray[npt.float]
+        ],  # TODO: Replace with Callable[[], Point3D]
         stroke_width: float = 2,
         stroke_color: ParsableManimColor | None = WHITE,
         dissipating_time: float | None = None,
@@ -155,7 +159,7 @@ def __init__(
         self.time = 1 if self.dissipating_time else None
         self.add_updater(self.update_path)
 
-    def update_path(self, mob, dt):
+    def update_path(self, _mob, dt):
         new_point = self.traced_point_func()
         if not self.has_points():
             self.start_new_path(new_point)

manim/animation/composition.py

@@ -13,14 +13,14 @@
 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
 
 if TYPE_CHECKING:
     from manim.mobject.opengl.opengl_vectorized_mobject import OpenGLVGroup
 
     from ..mobject.types.vectorized_mobject import VGroup
+    from .scene_buffer import SceneBuffer
 
 __all__ = ["AnimationGroup", "Succession", "LaggedStart", "LaggedStartMap"]
 
@@ -80,28 +80,28 @@ def __init__(
     def get_all_mobjects(self) -> Sequence[Mobject]:
         return list(self.group)
 
+    def get_all_animations(self) -> tuple[Animation, ...]:
+        return tuple(self.animations)
+
     def begin(self) -> None:
+        super().begin()
         if self.suspend_mobject_updating:
             self.group.suspend_updating()
-        for anim in self.animations:
-            anim.begin()
-
-    def _setup_scene(self, scene) -> None:
-        for anim in self.animations:
-            anim._setup_scene(scene)
 
     def finish(self) -> None:
         for anim in self.animations:
+            if self.remover:
+                anim.remover = self.remover
             anim.finish()
+            self.process_subanimation_buffer(anim.buffer)
+
         if self.suspend_mobject_updating:
             self.group.resume_updating()
+        self._on_finish(self.buffer)
 
-    def clean_up_from_scene(self, scene: Scene) -> None:
-        self._on_finish(scene)
-        for anim in self.animations:
-            if self.remover:
-                anim.remover = self.remover
-            anim.clean_up_from_scene(scene)
+    def process_subanimation_buffer(self, buffer: SceneBuffer) -> None:
+        self.buffer.add(*buffer.to_add)
+        self.buffer.remove(*buffer.to_remove)
 
     def update_mobjects(self, dt: float) -> None:
         for anim in self.animations:
@@ -198,6 +198,10 @@ def begin(self) -> None:
         assert len(self.animations) > 0
         self.update_active_animation(0)
 
+        for anim in self.animations:
+            if not anim.is_introducer() and anim.mobject is not None:
+                self.buffer.add(anim.mobject)
+
     def finish(self) -> None:
         while self.active_animation is not None:
             self.next_animation()
@@ -206,16 +210,6 @@ def update_mobjects(self, dt: float) -> None:
         if self.active_animation:
             self.active_animation.update_mobjects(dt)
 
-    def _setup_scene(self, scene) -> None:
-        if scene is None:
-            return
-        if self.is_introducer():
-            for anim in self.animations:
-                if not anim.is_introducer() and anim.mobject is not None:
-                    scene.add(anim.mobject)
-
-        self.scene = scene
-
     def update_active_animation(self, index: int) -> None:
         self.active_index = index
         if index >= len(self.animations):
@@ -224,7 +218,6 @@ def update_active_animation(self, index: int) -> None:
             self.active_end_time: float | None = None
         else:
             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]
@@ -236,6 +229,7 @@ def next_animation(self) -> None:
         """
         if self.active_animation is not None:
             self.active_animation.finish()
+            self.process_subanimation_buffer(self.active_animation.buffer)
         self.update_active_animation(self.active_index + 1)
 
     def interpolate(self, alpha: float) -> None:

manim/animation/creation.py

@@ -79,6 +79,8 @@ def construct(self):
 import numpy as np
 
 if TYPE_CHECKING:
+    from typing_extensions import Self
+
     from manim.mobject.text.text_mobject import Text
 
 from manim.mobject.opengl.opengl_surface import OpenGLSurface
@@ -92,7 +94,7 @@ def construct(self):
 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):
@@ -124,12 +126,13 @@ def interpolate_submobject(
         submobject: Mobject,
         starting_submobject: Mobject,
         alpha: float,
-    ) -> None:
+    ) -> Self:
         submobject.pointwise_become_partial(
             starting_submobject, *self._get_bounds(alpha)
         )
+        return self
 
-    def _get_bounds(self, alpha: float) -> None:
+    def _get_bounds(self, alpha: float) -> tuple[float, float]:
         raise NotImplementedError("Please use Create or ShowPassingFlash")
 
 
@@ -318,10 +321,10 @@ def __init__(
         vmobject: VMobject | OpenGLVMobject,
         rate_func: Callable[[float], float] = linear,
         reverse: bool = False,
+        run_time: float | None = None,
+        lag_ratio: float | None = None,
         **kwargs,
     ) -> None:
-        run_time: float | None = kwargs.pop("run_time", None)
-        lag_ratio: float | None = kwargs.pop("lag_ratio", None)
         run_time, lag_ratio = self._set_default_config_from_length(
             vmobject,
             run_time,

manim/animation/fading.py

@@ -80,12 +80,12 @@ def __init__(
         self.scale_factor = scale
         super().__init__(mobject, **kwargs)
 
-    def _create_faded_mobject(self, fadeIn: bool) -> Mobject:
+    def _create_faded_mobject(self, fade_in: bool) -> Mobject:
         """Create a faded, shifted and scaled copy of the mobject.
 
         Parameters
         ----------
-        fadeIn
+        fade_in
             Whether the faded mobject is used to fade in.
 
         Returns
@@ -95,7 +95,7 @@ def _create_faded_mobject(self, fadeIn: bool) -> Mobject:
         """
         faded_mobject = self.mobject.copy()
         faded_mobject.fade(1)
-        direction_modifier = -1 if fadeIn and not self.point_target else 1
+        direction_modifier = -1 if fade_in and not self.point_target else 1
         faded_mobject.shift(self.shift_vector * direction_modifier)
         faded_mobject.scale(self.scale_factor)
         return faded_mobject
@@ -191,8 +191,8 @@ def __init__(self, *mobjects: Mobject, **kwargs) -> None:
         super().__init__(*mobjects, remover=True, **kwargs)
 
     def create_target(self):
-        return self._create_faded_mobject(fadeIn=False)
+        return self._create_faded_mobject(fade_in=False)
 
-    def clean_up_from_scene(self, scene: Scene = None) -> None:
-        super().clean_up_from_scene(scene)
+    def begin(self) -> None:
+        super().begin()
         self.interpolate(0)

manim/animation/indication.py

@@ -37,7 +37,7 @@ def construct(self):
     "Wiggle",
 ]
 
-from typing import Callable, Iterable, Optional, Tuple, Type, Union
+from typing import Callable, Iterable, Optional, Type, Union
 
 import numpy as np
 
@@ -305,16 +305,16 @@ def __init__(self, mobject: "VMobject", time_width: float = 0.1, **kwargs) -> No
         self.time_width = time_width
         super().__init__(mobject, remover=True, introducer=True, **kwargs)
 
-    def _get_bounds(self, alpha: float) -> Tuple[float]:
+    def _get_bounds(self, alpha: float) -> tuple[float, float]:
         tw = self.time_width
         upper = interpolate(0, 1 + tw, alpha)
         lower = upper - tw
         upper = min(upper, 1)
         lower = max(lower, 0)
         return (lower, upper)
 
-    def clean_up_from_scene(self, scene: "Scene") -> None:
-        super().clean_up_from_scene(scene)
+    def finish(self) -> None:
+        super().finish()
         for submob, start in self.get_all_families_zipped():
             submob.pointwise_become_partial(start, 0, 1)
 
@@ -341,16 +341,6 @@ def __init__(self, vmobject, n_segments=10, time_width=0.1, remover=True, **kwar
         )
 
 
-@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.
 
@@ -469,7 +459,7 @@ def homotopy(
             y: float,
             z: float,
             t: float,
-        ) -> Tuple[float, float, float]:
+        ) -> tuple[float, float, float]:
             upper = interpolate(0, 1 + time_width, t)
             lower = upper - time_width
             relative_x = inverse_interpolate(x_min, x_max, x)
@@ -558,6 +548,7 @@ def interpolate_submobject(
         )
 
 
+# TODO: get rid of this if condition madness
 class Circumscribe(Succession):
     """Draw a temporary line surrounding the mobject.
 

manim/animation/movement.py

@@ -18,7 +18,8 @@
 from ..utils.rate_functions import linear
 
 if TYPE_CHECKING:
-    from ..mobject.mobject import Mobject, VMobject
+    from ..mobject.mobject import Mobject
+    from ..mobject.types.vectorized_mobject import VMobject
 
 
 class Homotopy(Animation):

manim/animation/speedmodifier.py

@@ -12,7 +12,6 @@
 from ..animation.animation import Animation, Wait, prepare_animation
 from ..animation.composition import AnimationGroup
 from ..mobject.mobject import Mobject, Updater, _AnimationBuilder
-from ..scene.scene import Scene
 
 
 class ChangeSpeed(Animation):
@@ -284,9 +283,10 @@ def finish(self) -> None:
 
     def begin(self) -> None:
         self.anim.begin()
+        self.buffer.add(*self.anim.buffer.to_add)
+        self.buffer.remove(*self.anim.buffer.to_remove)
 
-    def clean_up_from_scene(self, scene: Scene) -> None:
-        self.anim.clean_up_from_scene(scene)
-
-    def _setup_scene(self, scene) -> None:
-        self.anim._setup_scene(scene)
+    def finish(self) -> None:
+        self.anim.finish()
+        self.buffer.add(*self.anim.buffer.to_add)
+        self.buffer.remove(*self.anim.buffer.to_remove)

manim/animation/transform.py

@@ -205,10 +205,13 @@ def create_target(self) -> Mobject:
         # in subclasses
         return self.target_mobject
 
-    def clean_up_from_scene(self, scene: Scene) -> None:
-        super().clean_up_from_scene(scene)
+    def finish(self) -> None:
+        super().finish()
         if self.replace_mobject_with_target_in_scene:
-            scene.replace(self.mobject, self.target_mobject)
+            # Ideally this should stay at the same z-level as
+            # the original mobject, but this is difficult to implement
+            self.buffer.remove(self.mobject)
+            self.buffer.add(self.target_mobject)
 
     def get_all_mobjects(self) -> Sequence[Mobject]:
         return [
@@ -871,11 +874,11 @@ def get_all_mobjects(self) -> Sequence[Mobject]:
     def get_all_families_zipped(self):
         return Animation.get_all_families_zipped(self)
 
-    def clean_up_from_scene(self, scene):
-        Animation.clean_up_from_scene(self, scene)
-        scene.remove(self.mobject)
+    def finish(self):
+        Animation.finish(self)  # TODO: is this really needed over super()?
+        self.buffer.remove(self.mobject)
         self.mobject[0].restore()
-        scene.add(self.to_add_on_completion)
+        self.buffer.add(self.to_add_on_completion)
 
 
 class FadeTransformPieces(FadeTransform):