Type Annotations: Fixing errors showing up in static type checking tool mypy

manim/animation/animation.py

@@ -4,13 +4,10 @@
 __all__ = ["Animation", "Wait"]
 
 
-import typing
 from copy import deepcopy
-from typing import Union
+from typing import TYPE_CHECKING, Callable, Iterable, Optional, Tuple, Union
 
-import numpy as np
-
-if typing.TYPE_CHECKING:
+if TYPE_CHECKING:
     from manim.scene.scene import Scene
 
 from .. import logger
@@ -26,29 +23,29 @@
 class Animation:
     def __init__(
         self,
-        mobject: Mobject,
+        mobject: Union[Mobject, None],
         # If lag_ratio is 0, the animation is applied to all submobjects
         # at the same time
         # If 1, it is applied to each successively.
         # If 0 < lag_ratio < 1, its applied to each
         # with lagged start times
         lag_ratio: float = DEFAULT_ANIMATION_LAG_RATIO,
         run_time: float = DEFAULT_ANIMATION_RUN_TIME,
-        rate_func: typing.Callable[[float, float], np.ndarray] = smooth,
+        rate_func: Callable[[float], float] = smooth,
         name: str = None,
         remover: bool = False,  # remove a mobject from the screen?
         suspend_mobject_updating: bool = True,
         **kwargs,
     ) -> None:
         self._typecheck_input(mobject)
-        self.run_time = run_time
-        self.rate_func = rate_func
-        self.name = name
-        self.remover = remover
-        self.suspend_mobject_updating = suspend_mobject_updating
-        self.lag_ratio = lag_ratio
-        self.starting_mobject = None
-        self.mobject = mobject
+        self.run_time: float = run_time
+        self.rate_func: Callable[[float], float] = rate_func
+        self.name: Optional[str] = name
+        self.remover: bool = remover
+        self.suspend_mobject_updating: bool = suspend_mobject_updating
+        self.lag_ratio: float = lag_ratio
+        self.starting_mobject: Mobject = Mobject()
+        self.mobject: Mobject = mobject if mobject is not None else Mobject()
         if kwargs:
             logger.debug("Animation received extra kwargs: %s", kwargs)
 
@@ -60,9 +57,9 @@ def __init__(
                 )
             )
 
-    def _typecheck_input(self, mobject: Mobject) -> None:
+    def _typecheck_input(self, mobject: Union[Mobject, None]) -> None:
         if mobject is None:
-            logger.debug("creating dummy animation")
+            logger.debug("Animation with empty mobject")
         elif not isinstance(mobject, Mobject) and not isinstance(
             mobject, OpenGLMobject
         ):
@@ -94,7 +91,7 @@ def begin(self) -> None:
 
     def finish(self) -> None:
         self.interpolate(1)
-        if self.suspend_mobject_updating:
+        if self.suspend_mobject_updating and self.mobject is not None:
             self.mobject.resume_updating()
 
     def clean_up_from_scene(self, scene: "Scene") -> None:
@@ -105,13 +102,13 @@ def create_starting_mobject(self) -> Mobject:
         # Keep track of where the mobject starts
         return self.mobject.copy()
 
-    def get_all_mobjects(self) -> typing.Tuple[Mobject, typing.Union[Mobject, None]]:
+    def get_all_mobjects(self) -> Tuple[Mobject, Mobject]:
         """
         Ordering must match the ordering of arguments to interpolate_submobject
         """
         return self.mobject, self.starting_mobject
 
-    def get_all_families_zipped(self) -> typing.Iterator[typing.Tuple]:
+    def get_all_families_zipped(self) -> Iterable[Tuple]:
         return zip(
             *[mob.family_members_with_points() for mob in self.get_all_mobjects()]
         )
@@ -138,7 +135,7 @@ def copy(self) -> "Animation":
 
     # Methods for interpolation, the mean of an Animation
     def interpolate(self, alpha: float) -> None:
-        alpha = np.clip(alpha, 0, 1)
+        alpha = min(max(alpha, 0), 1)
         self.interpolate_mobject(self.rate_func(alpha))
 
     def update(self, alpha: float) -> None:
@@ -159,20 +156,24 @@ def interpolate_mobject(self, alpha: float) -> None:
             self.interpolate_submobject(*mobs, sub_alpha)
 
     def interpolate_submobject(
-        self, submobject: Mobject, starting_submobject: Mobject, alpha: float
-    ) -> None:
+        self,
+        submobject: Mobject,
+        starting_submobject: Mobject,
+        # target_copy: Mobject, #Todo: fix - signature of interpolate_submobject differes in Transform().
+        alpha: float,
+    ) -> "Animation":
         # Typically implemented by subclass
         pass
 
-    def get_sub_alpha(self, alpha: float, index: int, num_submobjects: int):
+    def get_sub_alpha(self, alpha: float, index: int, num_submobjects: int) -> float:
         # TODO, make this more understandable, and/or combine
         # its functionality with AnimationGroup's method
         # build_animations_with_timings
         lag_ratio = self.lag_ratio
         full_length = (num_submobjects - 1) * lag_ratio + 1
         value = alpha * full_length
         lower = index * lag_ratio
-        return np.clip((value - lower), 0, 1)
+        return min(max((value - lower), 0), 1)
 
     # Getters and setters
     def set_run_time(self, run_time: float) -> "Animation":
@@ -183,12 +184,15 @@ def get_run_time(self) -> float:
         return self.run_time
 
     def set_rate_func(
-        self, rate_func: typing.Callable[[float, float], np.ndarray]
+        self,
+        rate_func: Callable[[float], float],
     ) -> "Animation":
         self.rate_func = rate_func
         return self
 
-    def get_rate_func(self) -> typing.Callable[[float, float], np.ndarray]:
+    def get_rate_func(
+        self,
+    ) -> Callable[[float], float]:
         return self.rate_func
 
     def set_name(self, name: str) -> "Animation":
@@ -198,9 +202,6 @@ def set_name(self, name: str) -> "Animation":
     def is_remover(self) -> bool:
         return self.remover
 
-    def is_dummy(self) -> bool:
-        return self.mobject is None
-
 
 def prepare_animation(
     anim: Union["Animation", "mobject._AnimationBuilder"]
@@ -245,13 +246,14 @@ def prepare_animation(
 
 class Wait(Animation):
     def __init__(
-        self, duration: float = 1, stop_condition=None, **kwargs
+        self, run_time: float = 1, stop_condition=None, **kwargs
     ):  # what is stop_condition?
-        self.duration = duration
-        self.mobject = None
+        self.duration: float = run_time
         self.stop_condition = stop_condition
-        self.is_static_wait = False
-        super().__init__(None, **kwargs)
+        self.is_static_wait: bool = False
+        super().__init__(None, run_time=run_time, **kwargs)
+        # quick fix to work in opengl setting:
+        self.mobject.shader_wrapper_list = []
 
     def begin(self) -> None:
         pass

manim/animation/composition.py

@@ -1,5 +1,7 @@
 """Tools for displaying multiple animations at once."""
-import typing
+
+
+from typing import TYPE_CHECKING, Callable, Optional, Union
 
 import numpy as np
 
@@ -8,11 +10,10 @@
 from ..mobject.mobject import Group, Mobject
 from ..mobject.opengl_mobject import OpenGLGroup
 from ..scene.scene import Scene
-from ..utils.bezier import interpolate
 from ..utils.iterables import remove_list_redundancies
 from ..utils.rate_functions import linear
 
-if typing.TYPE_CHECKING:
+if TYPE_CHECKING:
     from ..mobject.types.opengl_vectorized_mobject import OpenGLVGroup
     from ..mobject.types.vectorized_mobject import VGroup
 
@@ -26,34 +27,28 @@ class AnimationGroup(Animation):
     def __init__(
         self,
         *animations: Animation,
-        group: typing.Union[Group, "VGroup", OpenGLGroup, "OpenGLVGroup"] = None,
-        run_time: float = None,
-        rate_func: typing.Callable[[float], float] = linear,
+        group: Union[Group, "VGroup", OpenGLGroup, "OpenGLVGroup"] = None,
+        run_time: Optional[float] = None,
+        rate_func: Callable[[float], float] = linear,
         lag_ratio: float = 0,
         **kwargs
     ) -> None:
         self.animations = [prepare_animation(anim) for anim in animations]
         self.group = group
         if self.group is None:
             mobjects = remove_list_redundancies(
-                [anim.mobject for anim in self.animations if not anim.is_dummy()]
+                [anim.mobject for anim in self.animations]
             )
             if config["renderer"] == "opengl":
                 self.group = OpenGLGroup(*mobjects)
             else:
                 self.group = Group(*mobjects)
         super().__init__(self.group, rate_func=rate_func, lag_ratio=lag_ratio, **kwargs)
-        self.run_time = run_time
-        self.init_run_time()
+        self.run_time: float = self.init_run_time(run_time)
 
     def get_all_mobjects(self) -> Group:
         return self.group
 
-    def get_run_time(self) -> float:
-        if super().get_run_time() is None:
-            self.init_run_time()
-        return super().get_run_time()
-
     def begin(self) -> None:
         for anim in self.animations:
             anim.begin()
@@ -70,28 +65,27 @@ def update_mobjects(self, dt: float) -> None:
         for anim in self.animations:
             anim.update_mobjects(dt)
 
-    def init_run_time(self) -> None:
+    def init_run_time(self, run_time) -> float:
         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
-        self.run_time = self.max_end_time if self.run_time is None else self.run_time
+        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 = 0
+        curr_time: float = 0
         for anim in self.animations:
-            start_time = curr_time
-            end_time = start_time + anim.get_run_time()
+            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 = interpolate(start_time, end_time, self.lag_ratio)
+            # Start time of next animation is based on the lag_ratio
+            curr_time = (1 - self.lag_ratio) * start_time + self.lag_ratio * end_time
 
     def interpolate(self, alpha: float) -> None:
         # Note, if the run_time of AnimationGroup has been
@@ -115,7 +109,6 @@ def __init__(self, *animations: Animation, lag_ratio: float = 1, **kwargs) -> No
 
     def begin(self) -> None:
         assert len(self.animations) > 0
-        self.init_run_time()
         self.update_active_animation(0)
 
     def finish(self) -> None:
@@ -129,24 +122,25 @@ def update_mobjects(self, dt: float) -> None:
     def update_active_animation(self, index: int) -> None:
         self.active_index = index
         if index >= len(self.animations):
-            self.active_animation = None
-            self.active_start_time = None
-            self.active_end_time = None
+            self.active_animation: Optional[Animation] = None
+            self.active_start_time: Optional[float] = None
+            self.active_end_time: Optional[float] = None
         else:
             self.active_animation = self.animations[index]
             self.active_animation.begin()
             self.active_start_time = self.anims_with_timings[index][1]
             self.active_end_time = self.anims_with_timings[index][2]
 
     def next_animation(self) -> None:
-        self.active_animation.finish()
+        if self.active_animation is not None:
+            self.active_animation.finish()
         self.update_active_animation(self.active_index + 1)
 
     def interpolate(self, alpha: float) -> None:
-        current_time = interpolate(0, self.run_time, alpha)
+        current_time = alpha * self.run_time
         while self.active_end_time is not None and current_time >= self.active_end_time:
             self.next_animation()
-        if self.active_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()
             subalpha = elapsed / active_run_time if active_run_time != 0.0 else 1.0
@@ -166,9 +160,9 @@ def __init__(
 class LaggedStartMap(LaggedStart):
     def __init__(
         self,
-        AnimationClass: Animation,
+        AnimationClass: Callable[..., Animation],
         mobject: Mobject,
-        arg_creator: typing.Callable[[Mobject], str] = None,
+        arg_creator: Callable[[Mobject], str] = None,
         run_time: float = 2,
         **kwargs
     ) -> None: