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

manim/mobject/mobject.py

@@ -1,35 +1,25 @@
 """Base classes for objects that can be displayed."""
+
 from __future__ import annotations
 
 __all__ = ["Mobject", "Group", "override_animate"]
 
 
 import copy
+import inspect
 import itertools as it
+import math
 import operator as op
 import random
 import sys
 import types
 import warnings
 from functools import partialmethod, reduce
-from math import ceil
 from pathlib import Path
-from typing import (
-    TYPE_CHECKING,
-    Callable,
-    Dict,
-    Iterable,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    Type,
-    TypeVar,
-    Union,
-)
+from typing import TYPE_CHECKING, Callable, Iterable, Literal, TypeVar, Union
 
 import numpy as np
-from colour import Color
+from typing_extensions import Self, TypeAlias
 
 from manim.mobject.opengl.opengl_compatibility import ConvertToOpenGL
 
@@ -39,22 +29,37 @@ from ..utils.color import (
     BLACK,
     WHITE,
     YELLOW_C,
-    Colors,
+    ManimColor,
+    ParsableManimColor,
     color_gradient,
     interpolate_color,
 )
 from ..utils.exceptions import MultiAnimationOverrideException
 from ..utils.iterables import list_update, remove_list_redundancies
 from ..utils.paths import straight_path
-from ..utils.simple_functions import get_parameters
 from ..utils.space_ops import angle_between_vectors, normalize, rotation_matrix
 
 # TODO: Explain array_attrs
 
-Updater = Union[Callable[["Mobject"], None], Callable[["Mobject", float], None]]
+TimeBasedUpdater: TypeAlias = Callable[["Mobject", float], None]
+NonTimeBasedUpdater: TypeAlias = Callable[["Mobject"], None]
+Updater: TypeAlias = Union[NonTimeBasedUpdater, TimeBasedUpdater]
 T = TypeVar("T", bound="Mobject")
 
 if TYPE_CHECKING:
+    from manim.typing import (
+        FunctionOverride,
+        Image,
+        ManimFloat,
+        ManimInt,
+        MappingFunction,
+        PathFuncType,
+        Point3D,
+        Point3D_Array,
+        Vector,
+        Vector3,
+    )
+
     from ..animation.animation import Animation
 
 
@@ -81,26 +86,33 @@ class Mobject:
     animation_overrides = {}
 
     @classmethod
-    def __init_subclass__(cls, **kwargs):
+    def __init_subclass__(cls, **kwargs) -> None:
         super().__init_subclass__(**kwargs)
 
         cls.animation_overrides: dict[
             type[Animation],
-            Callable[[Mobject], Animation],
+            FunctionOverride,
         ] = {}
         cls._add_intrinsic_animation_overrides()
         cls._original__init__ = cls.__init__
 
-    def __init__(self, color=WHITE, name=None, dim=3, target=None, z_index=0):
+    def __init__(
+        self,
+        color: ParsableManimColor | list[ParsableManimColor] = WHITE,
+        name: str | None = None,
+        dim: int = 3,
+        target=None,
+        z_index: float = 0,
+    ) -> None:
         self.name = self.__class__.__name__ if name is None else name
         self.dim = dim
         self.target = target
         self.z_index = z_index
         self.point_hash = None
         self.submobjects = []
-        self.updaters = []
+        self.updaters: list[Updater] = []
         self.updating_suspended = False
-        self.color = Color(color) if color else None
+        self.color = ManimColor.parse(color)
 
         self.reset_points()
         self.generate_points()
@@ -110,7 +122,7 @@ class Mobject:
     def animation_override_for(
         cls,
         animation_class: type[Animation],
-    ) -> Callable[[Mobject, ...], Animation] | None:
+    ) -> FunctionOverride | None:
         """Returns the function defining a specific animation override for this class.
 
         Parameters
@@ -130,7 +142,7 @@ class Mobject:
         return None
 
     @classmethod
-    def _add_intrinsic_animation_overrides(cls):
+    def _add_intrinsic_animation_overrides(cls) -> None:
         """Initializes animation overrides marked with the :func:`~.override_animation`
         decorator.
         """
@@ -148,8 +160,8 @@ class Mobject:
     def add_animation_override(
         cls,
         animation_class: type[Animation],
-        override_func: Callable[[Mobject, ...], Animation],
-    ):
+        override_func: FunctionOverride,
+    ) -> None:
         """Add an animation override.
 
         This does not apply to subclasses.
@@ -160,7 +172,7 @@ class Mobject:
             The animation type to be overridden
         override_func
             The function returning an animation replacing the default animation. It gets
-            passed the parameters given to the animnation constructor.
+            passed the parameters given to the animation constructor.
 
         Raises
         ------
@@ -178,7 +190,7 @@ class Mobject:
             )
 
     @classmethod
-    def set_default(cls, **kwargs):
+    def set_default(cls, **kwargs) -> None:
         """Sets the default values of keyword arguments.
 
         If this method is called without any additional keyword
@@ -201,10 +213,10 @@ class Mobject:
             >>> from manim import Square, GREEN
             >>> Square.set_default(color=GREEN, fill_opacity=0.25)
             >>> s = Square(); s.color, s.fill_opacity
-            (<Color #83c167>, 0.25)
+            (ManimColor('#83C167'), 0.25)
             >>> Square.set_default()
             >>> s = Square(); s.color, s.fill_opacity
-            (<Color white>, 0.0)
+            (ManimColor('#FFFFFF'), 0.0)
 
         .. manim:: ChangedDefaultTextcolor
             :save_last_frame:
@@ -323,7 +335,7 @@ class Mobject:
         """
         return _AnimationBuilder(self)
 
-    def __deepcopy__(self, clone_from_id):
+    def __deepcopy__(self, clone_from_id) -> Self:
         cls = self.__class__
         result = cls.__new__(cls)
         clone_from_id[id(self)] = result
@@ -332,30 +344,28 @@ class Mobject:
         result.original_id = str(id(self))
         return result
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return str(self.name)
 
-    def reset_points(self):
+    def reset_points(self) -> None:
         """Sets :attr:`points` to be an empty array."""
         self.points = np.zeros((0, self.dim))
 
-    def init_colors(self):
+    def init_colors(self) -> None:
         """Initializes the colors.
 
         Gets called upon creation. This is an empty method that can be implemented by
         subclasses.
         """
-        pass
 
-    def generate_points(self):
+    def generate_points(self) -> None:
         """Initializes :attr:`points` and therefore the shape.
 
         Gets called upon creation. This is an empty method that can be implemented by
         subclasses.
         """
-        pass
 
-    def add(self, *mobjects: Mobject):
+    def add(self, *mobjects: Mobject) -> Self:
         """Add mobjects as submobjects.
 
         The mobjects are added to :attr:`submobjects`.
@@ -441,7 +451,7 @@ class Mobject:
         self.submobjects = list_update(self.submobjects, unique_mobjects)
         return self
 
-    def insert(self, index: int, mobject: Mobject):
+    def insert(self, index: int, mobject: Mobject) -> None:
         """Inserts a mobject at a specific position into self.submobjects
 
         Effectively just calls  ``self.submobjects.insert(index, mobject)``,
@@ -462,13 +472,13 @@ class Mobject:
             raise ValueError("Mobject cannot contain self")
         self.submobjects.insert(index, mobject)
 
-    def __add__(self, mobject):
+    def __add__(self, mobject: Mobject):
         raise NotImplementedError
 
-    def __iadd__(self, mobject):
+    def __iadd__(self, mobject: Mobject):
         raise NotImplementedError
 
-    def add_to_back(self, *mobjects: Mobject):
+    def add_to_back(self, *mobjects: Mobject) -> Self:
         """Add all passed mobjects to the back of the submobjects.
 
         If :attr:`submobjects` already contains the given mobjects, they just get moved
@@ -524,7 +534,7 @@ class Mobject:
         self.submobjects = list(dict.fromkeys(mobjects)) + self.submobjects
         return self
 
-    def remove(self, *mobjects: Mobject):
+    def remove(self, *mobjects: Mobject) -> Self:
         """Remove :attr:`submobjects`.
 
         The mobjects are removed from :attr:`submobjects`, if they exist.
@@ -557,7 +567,7 @@ class Mobject:
     def __isub__(self, other):
         raise NotImplementedError
 
-    def set(self, **kwargs):
+    def set(self, **kwargs) -> Self:
         """Sets attributes.
 
         I.e. ``my_mobject.set(foo=1)`` applies ``my_mobject.foo = 1``.
@@ -614,7 +624,7 @@ class Mobject:
 
         return self
 
-    def __getattr__(self, attr):
+    def __getattr__(self, attr: str) -> types.MethodType:
         # Add automatic compatibility layer
         # between properties and get_* and set_*
         # methods.
@@ -662,7 +672,7 @@ class Mobject:
         raise AttributeError(f"{type(self).__name__} object has no attribute '{attr}'")
 
     @property
-    def width(self):
+    def width(self) -> float:
         """The width of the mobject.
 
         Returns
@@ -695,11 +705,11 @@ class Mobject:
         return self.length_over_dim(0)
 
     @width.setter
-    def width(self, value):
+    def width(self, value: float):
         self.scale_to_fit_width(value)
 
     @property
-    def height(self):
+    def height(self) -> float:
         """The height of the mobject.
 
         Returns
@@ -732,11 +742,11 @@ class Mobject:
         return self.length_over_dim(1)
 
     @height.setter
-    def height(self, value):
+    def height(self, value: float):
         self.scale_to_fit_height(value)
 
     @property
-    def depth(self):
+    def depth(self) -> float:
         """The depth of the mobject.
 
         Returns
@@ -753,20 +763,21 @@ class Mobject:
         return self.length_over_dim(2)
 
     @depth.setter
-    def depth(self, value):
+    def depth(self, value: float):
         self.scale_to_fit_depth(value)
 
-    def get_array_attrs(self):
+    # Can't be staticmethod because of point_cloud_mobject.py
+    def get_array_attrs(self) -> list[Literal["points"]]:
         return ["points"]
 
-    def apply_over_attr_arrays(self, func):
+    def apply_over_attr_arrays(self, func: MappingFunction) -> Self:
         for attr in self.get_array_attrs():
             setattr(self, attr, func(getattr(self, attr)))
         return self
 
     # Displaying
 
-    def get_image(self, camera=None):
+    def get_image(self, camera=None) -> Image:
         if camera is None:
             from ..camera.camera import Camera
 
@@ -774,17 +785,17 @@ class Mobject:
         camera.capture_mobject(self)
         return camera.get_image()
 
-    def show(self, camera=None):
+    def show(self, camera=None) -> None:
         self.get_image(camera=camera).show()
 
-    def save_image(self, name=None):
+    def save_image(self, name: str | None = None) -> None:
         """Saves an image of only this :class:`Mobject` at its position to a png
         file."""
         self.get_image().save(
             Path(config.get_dir("video_dir")).joinpath((name or str(self)) + ".png"),
         )
 
-    def copy(self: T) -> T:
+    def copy(self) -> Self:
         """Create and return an identical copy of the :class:`Mobject` including all
         :attr:`submobjects`.
 
@@ -799,7 +810,7 @@ class Mobject:
         """
         return copy.deepcopy(self)
 
-    def generate_target(self, use_deepcopy=False):
+    def generate_target(self, use_deepcopy: bool = False) -> Self:
         self.target = None  # Prevent unbounded linear recursion
         if use_deepcopy:
             self.target = copy.deepcopy(self)
@@ -809,7 +820,7 @@ class Mobject:
 
     # Updating
 
-    def update(self, dt: float = 0, recursive: bool = True):
+    def update(self, dt: float = 0, recursive: bool = True) -> Self:
         """Apply all updaters.
 
         Does nothing if updating is suspended.
@@ -836,8 +847,7 @@ class Mobject:
         if self.updating_suspended:
             return self
         for updater in self.updaters:
-            parameters = get_parameters(updater)
-            if "dt" in parameters:
+            if "dt" in inspect.signature(updater).parameters:
                 updater(self, dt)
             else:
                 updater(self)
@@ -846,7 +856,7 @@ class Mobject:
                 submob.update(dt, recursive)
         return self
 
-    def get_time_based_updaters(self) -> list[Updater]:
+    def get_time_based_updaters(self) -> list[TimeBasedUpdater]:
         """Return all updaters using the ``dt`` parameter.
 
         The updaters use this parameter as the input for difference in time.
@@ -862,7 +872,11 @@ class Mobject:
         :meth:`has_time_based_updater`
 
         """
-        return [updater for updater in self.updaters if "dt" in get_parameters(updater)]
+        return [
+            updater
+            for updater in self.updaters
+            if "dt" in inspect.signature(updater).parameters
+        ]
 
     def has_time_based_updater(self) -> bool:
         """Test if ``self`` has a time based updater.
@@ -878,7 +892,9 @@ class Mobject:
         :meth:`get_time_based_updaters`
 
         """
-        return any("dt" in get_parameters(updater) for updater in self.updaters)
+        return any(
+            "dt" in inspect.signature(updater).parameters for updater in self.updaters
+        )
 
     def get_updaters(self) -> list[Updater]:
         """Return all updaters.
@@ -896,7 +912,7 @@ class Mobject:
         """
         return self.updaters
 
-    def get_family_updaters(self):
+    def get_family_updaters(self) -> list[Updater]:
         return list(it.chain(*(sm.get_updaters() for sm in self.get_family())))
 
     def add_updater(
@@ -904,7 +920,7 @@ class Mobject:
         update_function: Updater,
         index: int | None = None,
         call_updater: bool = False,
-    ):
+    ) -> Self:
         """Add an update function to this mobject.
 
         Update functions, or updaters in short, are functions that are applied to the
@@ -971,14 +987,14 @@ class Mobject:
         else:
             self.updaters.insert(index, update_function)
         if call_updater:
-            parameters = get_parameters(update_function)
+            parameters = inspect.signature(update_function).parameters
             if "dt" in parameters:
                 update_function(self, 0)
             else:
                 update_function(self)
         return self
 
-    def remove_updater(self, update_function: Updater):
+    def remove_updater(self, update_function: Updater) -> Self:
         """Remove an updater.
 
         If the same updater is applied multiple times, every instance gets removed.
@@ -1005,7 +1021,7 @@ class Mobject:
             self.updaters.remove(update_function)
         return self
 
-    def clear_updaters(self, recursive: bool = True):
+    def clear_updaters(self, recursive: bool = True) -> Self:
         """Remove every updater.
 
         Parameters
@@ -1031,7 +1047,7 @@ class Mobject:
                 submob.clear_updaters()
         return self
 
-    def match_updaters(self, mobject: Mobject):
+    def match_updaters(self, mobject: Mobject) -> Self:
         """Match the updaters of the given mobject.
 
         Parameters
@@ -1061,7 +1077,7 @@ class Mobject:
             self.add_updater(updater)
         return self
 
-    def suspend_updating(self, recursive: bool = True):
+    def suspend_updating(self, recursive: bool = True) -> Self:
         """Disable updating from updaters and animations.
 
 
@@ -1088,7 +1104,7 @@ class Mobject:
                 submob.suspend_updating(recursive)
         return self
 
-    def resume_updating(self, recursive: bool = True):
+    def resume_updating(self, recursive: bool = True) -> Self:
         """Enable updating from updaters and animations.
 
         Parameters
@@ -1116,7 +1132,7 @@ class Mobject:
 
     # Transforming operations
 
-    def apply_to_family(self, func: Callable[[Mobject], None]):
+    def apply_to_family(self, func: Callable[[Mobject], None]) -> None:
         """Apply a function to ``self`` and every submobject with points recursively.
 
         Parameters
@@ -1138,7 +1154,7 @@ class Mobject:
         for mob in self.family_members_with_points():
             func(mob)
 
-    def shift(self, *vectors: np.ndarray):
+    def shift(self, *vectors: Vector3) -> Self:
         """Shift by the given vectors.
 
         Parameters
@@ -1164,7 +1180,7 @@ class Mobject:
 
         return self
 
-    def scale(self, scale_factor: float, **kwargs):
+    def scale(self, scale_factor: float, **kwargs) -> Self:
         r"""Scale the size by a factor.
 
         Default behavior is to scale about the center of the mobject.
@@ -1210,17 +1226,17 @@ class Mobject:
         )
         return self
 
-    def rotate_about_origin(self, angle, axis=OUT, axes=[]):
+    def rotate_about_origin(self, angle: float, axis: Vector3 = OUT, axes=[]) -> Self:
         """Rotates the :class:`~.Mobject` about the ORIGIN, which is at [0,0,0]."""
         return self.rotate(angle, axis, about_point=ORIGIN)
 
     def rotate(
         self,
-        angle,
-        axis=OUT,
-        about_point: Sequence[float] | None = None,
+        angle: float,
+        axis: Vector3 = OUT,
+        about_point: Point3D | None = None,
         **kwargs,
-    ):
+    ) -> Self:
         """Rotates the :class:`~.Mobject` about a certain point."""
         rot_matrix = rotation_matrix(angle, axis)
         self.apply_points_function_about_point(
@@ -1228,7 +1244,7 @@ class Mobject:
         )
         return self
 
-    def flip(self, axis=UP, **kwargs):
+    def flip(self, axis: Vector3 = UP, **kwargs) -> Self:
         """Flips/Mirrors an mobject about its center.
 
         Examples
@@ -1247,7 +1263,7 @@ class Mobject:
         """
         return self.rotate(TAU / 2, axis, **kwargs)
 
-    def stretch(self, factor, dim, **kwargs):
+    def stretch(self, factor: float, dim: int, **kwargs) -> Self:
         def func(points):
             points[:, dim] *= factor
             return points
@@ -1255,7 +1271,7 @@ class Mobject:
         self.apply_points_function_about_point(func, **kwargs)
         return self
 
-    def apply_function(self, function, **kwargs):
+    def apply_function(self, function: MappingFunction, **kwargs) -> Self:
         # Default to applying matrix about the origin, not mobjects center
         if len(kwargs) == 0:
             kwargs["about_point"] = ORIGIN
@@ -1264,16 +1280,16 @@ class Mobject:
         )
         return self
 
-    def apply_function_to_position(self, function):
+    def apply_function_to_position(self, function: MappingFunction) -> Self:
         self.move_to(function(self.get_center()))
         return self
 
-    def apply_function_to_submobject_positions(self, function):
+    def apply_function_to_submobject_positions(self, function: MappingFunction) -> Self:
         for submob in self.submobjects:
             submob.apply_function_to_position(function)
         return self
 
-    def apply_matrix(self, matrix, **kwargs):
+    def apply_matrix(self, matrix, **kwargs) -> Self:
         # Default to applying matrix about the origin, not mobjects center
         if ("about_point" not in kwargs) and ("about_edge" not in kwargs):
             kwargs["about_point"] = ORIGIN
@@ -1285,9 +1301,11 @@ class Mobject:
         )
         return self
 
-    def apply_complex_function(self, function, **kwargs):
+    def apply_complex_function(
+        self, function: Callable[[complex], complex], **kwargs
+    ) -> Self:
         """Applies a complex function to a :class:`Mobject`.
-        The x and y coordinates correspond to the real and imaginary parts respectively.
+        The x and y Point3Ds correspond to the real and imaginary parts respectively.
 
         Example
         -------
@@ -1319,7 +1337,9 @@ class Mobject:
 
         return self.apply_function(R3_func)
 
-    def wag(self, direction=RIGHT, axis=DOWN, wag_factor=1.0):
+    def wag(
+        self, direction: Vector3 = RIGHT, axis: Vector3 = DOWN, wag_factor: float = 1.0
+    ) -> Self:
         for mob in self.family_members_with_points():
             alphas = np.dot(mob.points, np.transpose(axis))
             alphas -= min(alphas)
@@ -1331,12 +1351,12 @@ class Mobject:
             )
         return self
 
-    def reverse_points(self):
+    def reverse_points(self) -> Self:
         for mob in self.family_members_with_points():
             mob.apply_over_attr_arrays(lambda arr: np.array(list(reversed(arr))))
         return self
 
-    def repeat(self, count: int):
+    def repeat(self, count: int) -> Self:
         """This can make transition animations nicer"""
 
         def repeat_array(array):
@@ -1352,10 +1372,10 @@ class Mobject:
 
     def apply_points_function_about_point(
         self,
-        func,
-        about_point=None,
+        func: MappingFunction,
+        about_point: Point3D = None,
         about_edge=None,
-    ):
+    ) -> Self:
         if about_point is None:
             if about_edge is None:
                 about_edge = ORIGIN
@@ -1372,11 +1392,20 @@ class Mobject:
 
     # Positioning methods
 
-    def center(self):
+    def center(self) -> Self:
+        """Moves the center of the mobject to the center of the scene.
+
+        Returns
+        -------
+        :class:`.Mobject`
+            The centered mobject.
+        """
         self.shift(-self.get_center())
         return self
 
-    def align_on_border(self, direction, buff=DEFAULT_MOBJECT_TO_EDGE_BUFFER):
+    def align_on_border(
+        self, direction: Vector3, buff: float = DEFAULT_MOBJECT_TO_EDGE_BUFFER
+    ) -> Self:
         """Direction just needs to be a vector pointing towards side or
         corner in the 2d plane.
         """
@@ -1391,23 +1420,27 @@ class Mobject:
         self.shift(shift_val)
         return self
 
-    def to_corner(self, corner=LEFT + DOWN, buff=DEFAULT_MOBJECT_TO_EDGE_BUFFER):
+    def to_corner(
+        self, corner: Vector3 = DL, buff: float = DEFAULT_MOBJECT_TO_EDGE_BUFFER
+    ) -> Self:
         return self.align_on_border(corner, buff)
 
-    def to_edge(self, edge=LEFT, buff=DEFAULT_MOBJECT_TO_EDGE_BUFFER):
+    def to_edge(
+        self, edge: Vector3 = LEFT, buff: float = DEFAULT_MOBJECT_TO_EDGE_BUFFER
+    ) -> Self:
         return self.align_on_border(edge, buff)
 
     def next_to(
         self,
-        mobject_or_point,
-        direction=RIGHT,
-        buff=DEFAULT_MOBJECT_TO_MOBJECT_BUFFER,
-        aligned_edge=ORIGIN,
-        submobject_to_align=None,
-        index_of_submobject_to_align=None,
-        coor_mask=np.array([1, 1, 1]),
-    ):
-        """Move this :class:`~.Mobject` next to another's :class:`~.Mobject` or coordinate.
+        mobject_or_point: Mobject | Point3D,
+        direction: Vector3 = RIGHT,
+        buff: float = DEFAULT_MOBJECT_TO_MOBJECT_BUFFER,
+        aligned_edge: Vector3 = ORIGIN,
+        submobject_to_align: Mobject | None = None,
+        index_of_submobject_to_align: int | None = None,
+        coor_mask: Vector3 = np.array([1, 1, 1]),
+    ) -> Self:
+        """Move this :class:`~.Mobject` next to another's :class:`~.Mobject` or Point3D.
 
         Examples
         --------
@@ -1446,7 +1479,7 @@ class Mobject:
         self.shift((target_point - point_to_align + buff * direction) * coor_mask)
         return self
 
-    def shift_onto_screen(self, **kwargs):
+    def shift_onto_screen(self, **kwargs) -> Self:
         space_lengths = [config["frame_x_radius"], config["frame_y_radius"]]
         for vect in UP, DOWN, LEFT, RIGHT:
             dim = np.argmax(np.abs(vect))
@@ -1468,10 +1501,12 @@ class Mobject:
             return True
         return False
 
-    def stretch_about_point(self, factor, dim, point):
+    def stretch_about_point(self, factor: float, dim: int, point: Point3D) -> Self:
         return self.stretch(factor, dim, about_point=point)
 
-    def rescale_to_fit(self, length, dim, stretch=False, **kwargs):
+    def rescale_to_fit(
+        self, length: float, dim: int, stretch: bool = False, **kwargs
+    ) -> Self:
         old_length = self.length_over_dim(dim)
         if old_length == 0:
             return self
@@ -1481,7 +1516,7 @@ class Mobject:
             self.scale(length / old_length, **kwargs)
         return self
 
-    def scale_to_fit_width(self, width, **kwargs):
+    def scale_to_fit_width(self, width: float, **kwargs) -> Self:
         """Scales the :class:`~.Mobject` to fit a width while keeping height/depth proportional.
 
         Returns
@@ -1507,7 +1542,7 @@ class Mobject:
 
         return self.rescale_to_fit(width, 0, stretch=False, **kwargs)
 
-    def stretch_to_fit_width(self, width, **kwargs):
+    def stretch_to_fit_width(self, width: float, **kwargs) -> Self:
         """Stretches the :class:`~.Mobject` to fit a width, not keeping height/depth proportional.
 
         Returns
@@ -1533,7 +1568,7 @@ class Mobject:
 
         return self.rescale_to_fit(width, 0, stretch=True, **kwargs)
 
-    def scale_to_fit_height(self, height, **kwargs):
+    def scale_to_fit_height(self, height: float, **kwargs) -> Self:
         """Scales the :class:`~.Mobject` to fit a height while keeping width/depth proportional.
 
         Returns
@@ -1559,7 +1594,7 @@ class Mobject:
 
         return self.rescale_to_fit(height, 1, stretch=False, **kwargs)
 
-    def stretch_to_fit_height(self, height, **kwargs):
+    def stretch_to_fit_height(self, height: float, **kwargs) -> Self:
         """Stretches the :class:`~.Mobject` to fit a height, not keeping width/depth proportional.
 
         Returns
@@ -1585,36 +1620,36 @@ class Mobject:
 
         return self.rescale_to_fit(height, 1, stretch=True, **kwargs)
 
-    def scale_to_fit_depth(self, depth, **kwargs):
+    def scale_to_fit_depth(self, depth: float, **kwargs) -> Self:
         """Scales the :class:`~.Mobject` to fit a depth while keeping width/height proportional."""
 
         return self.rescale_to_fit(depth, 2, stretch=False, **kwargs)
 
-    def stretch_to_fit_depth(self, depth, **kwargs):
+    def stretch_to_fit_depth(self, depth: float, **kwargs) -> Self:
         """Stretches the :class:`~.Mobject` to fit a depth, not keeping width/height proportional."""
 
         return self.rescale_to_fit(depth, 2, stretch=True, **kwargs)
 
-    def set_coord(self, value, dim, direction=ORIGIN):
+    def set_coord(self, value, dim: int, direction: Vector3 = ORIGIN) -> Self:
         curr = self.get_coord(dim, direction)
         shift_vect = np.zeros(self.dim)
         shift_vect[dim] = value - curr
         self.shift(shift_vect)
         return self
 
-    def set_x(self, x, direction=ORIGIN):
+    def set_x(self, x: float, direction: Vector3 = ORIGIN) -> Self:
         """Set x value of the center of the :class:`~.Mobject` (``int`` or ``float``)"""
         return self.set_coord(x, 0, direction)
 
-    def set_y(self, y, direction=ORIGIN):
+    def set_y(self, y: float, direction: Vector3 = ORIGIN) -> Self:
         """Set y value of the center of the :class:`~.Mobject` (``int`` or ``float``)"""
         return self.set_coord(y, 1, direction)
 
-    def set_z(self, z, direction=ORIGIN):
+    def set_z(self, z: float, direction: Vector3 = ORIGIN) -> Self:
         """Set z value of the center of the :class:`~.Mobject` (``int`` or ``float``)"""
         return self.set_coord(z, 2, direction)
 
-    def space_out_submobjects(self, factor=1.5, **kwargs):
+    def space_out_submobjects(self, factor: float = 1.5, **kwargs) -> Self:
         self.scale(factor, **kwargs)
         for submob in self.submobjects:
             submob.scale(1.0 / factor)
@@ -1622,11 +1657,11 @@ class Mobject:
 
     def move_to(
         self,
-        point_or_mobject,
-        aligned_edge=ORIGIN,
-        coor_mask=np.array([1, 1, 1]),
-    ):
-        """Move center of the :class:`~.Mobject` to certain coordinate."""
+        point_or_mobject: Point3D | Mobject,
+        aligned_edge: Vector3 = ORIGIN,
+        coor_mask: Vector3 = np.array([1, 1, 1]),
+    ) -> Self:
+        """Move center of the :class:`~.Mobject` to certain Point3D."""
         if isinstance(point_or_mobject, Mobject):
             target = point_or_mobject.get_critical_point(aligned_edge)
         else:
@@ -1635,7 +1670,9 @@ class Mobject:
         self.shift((target - point_to_align) * coor_mask)
         return self
 
-    def replace(self, mobject, dim_to_match=0, stretch=False):
+    def replace(
+        self, mobject: Mobject, dim_to_match: int = 0, stretch: bool = False
+    ) -> Self:
         if not mobject.get_num_points() and not mobject.submobjects:
             raise Warning("Attempting to replace mobject with no points")
         if stretch:
@@ -1653,16 +1690,16 @@ class Mobject:
     def surround(
         self,
         mobject: Mobject,
-        dim_to_match=0,
-        stretch=False,
-        buff=MED_SMALL_BUFF,
-    ):
+        dim_to_match: int = 0,
+        stretch: bool = False,
+        buff: float = MED_SMALL_BUFF,
+    ) -> Self:
         self.replace(mobject, dim_to_match, stretch)
         length = mobject.length_over_dim(dim_to_match)
         self.scale((length + buff) / length)
         return self
 
-    def put_start_and_end_on(self, start, end):
+    def put_start_and_end_on(self, start: Point3D, end: Point3D) -> Self:
         curr_start, curr_end = self.get_start_and_end()
         curr_vect = curr_end - curr_start
         if np.all(curr_vect == 0):
@@ -1687,8 +1724,8 @@ class Mobject:
 
     # Background rectangle
     def add_background_rectangle(
-        self, color: Colors | None = None, opacity: float = 0.75, **kwargs
-    ):
+        self, color: ParsableManimColor | None = None, opacity: float = 0.75, **kwargs
+    ) -> Self:
         """Add a BackgroundRectangle as submobject.
 
         The BackgroundRectangle is added behind other submobjects.
@@ -1727,19 +1764,21 @@ class Mobject:
         self.add_to_back(self.background_rectangle)
         return self
 
-    def add_background_rectangle_to_submobjects(self, **kwargs):
+    def add_background_rectangle_to_submobjects(self, **kwargs) -> Self:
         for submobject in self.submobjects:
             submobject.add_background_rectangle(**kwargs)
         return self
 
-    def add_background_rectangle_to_family_members_with_points(self, **kwargs):
+    def add_background_rectangle_to_family_members_with_points(self, **kwargs) -> Self:
         for mob in self.family_members_with_points():
             mob.add_background_rectangle(**kwargs)
         return self
 
     # Color functions
 
-    def set_color(self, color: Color = YELLOW_C, family: bool = True):
+    def set_color(
+        self, color: ParsableManimColor = YELLOW_C, family: bool = True
+    ) -> Self:
         """Condition is function which takes in one arguments, (x, y, z).
         Here it just recurses to submobjects, but in subclasses this
         should be further implemented based on the the inner workings
@@ -1748,20 +1787,30 @@ class Mobject:
         if family:
             for submob in self.submobjects:
                 submob.set_color(color, family=family)
-        self.color = Color(color)
+
+        self.color = ManimColor.parse(color)
         return self
 
-    def set_color_by_gradient(self, *colors):
+    def set_color_by_gradient(self, *colors: ParsableManimColor) -> Self:
+        """
+        Parameters
+        ----------
+        colors
+            The colors to use for the gradient. Use like `set_color_by_gradient(RED, BLUE, GREEN)`.
+
+        self.color = ManimColor.parse(color)
+        return self
+        """
         self.set_submobject_colors_by_gradient(*colors)
         return self
 
     def set_colors_by_radial_gradient(
         self,
-        center=None,
-        radius=1,
-        inner_color=WHITE,
-        outer_color=BLACK,
-    ):
+        center: Point3D | None = None,
+        radius: float = 1,
+        inner_color: ParsableManimColor = WHITE,
+        outer_color: ParsableManimColor = BLACK,
+    ) -> Self:
         self.set_submobject_colors_by_radial_gradient(
             center,
             radius,
@@ -1770,7 +1819,7 @@ class Mobject:
         )
         return self
 
-    def set_submobject_colors_by_gradient(self, *colors):
+    def set_submobject_colors_by_gradient(self, *colors: Iterable[ParsableManimColor]):
         if len(colors) == 0:
             raise ValueError("Need at least one color")
         elif len(colors) == 1:
@@ -1785,11 +1834,11 @@ class Mobject:
 
     def set_submobject_colors_by_radial_gradient(
         self,
-        center=None,
-        radius=1,
-        inner_color=WHITE,
-        outer_color=BLACK,
-    ):
+        center: Point3D | None = None,
+        radius: float = 1,
+        inner_color: ParsableManimColor = WHITE,
+        outer_color: ParsableManimColor = BLACK,
+    ) -> Self:
         if center is None:
             center = self.get_center()
 
@@ -1801,11 +1850,13 @@ class Mobject:
 
         return self
 
-    def to_original_color(self):
+    def to_original_color(self) -> Self:
         self.set_color(self.color)
         return self
 
-    def fade_to(self, color, alpha, family=True):
+    def fade_to(
+        self, color: ParsableManimColor, alpha: float, family: bool = True
+    ) -> Self:
         if self.get_num_points() > 0:
             new_color = interpolate_color(self.get_color(), color, alpha)
             self.set_color(new_color, family=False)
@@ -1814,19 +1865,19 @@ class Mobject:
                 submob.fade_to(color, alpha)
         return self
 
-    def fade(self, darkness=0.5, family=True):
+    def fade(self, darkness: float = 0.5, family: bool = True) -> Self:
         if family:
             for submob in self.submobjects:
                 submob.fade(darkness, family)
         return self
 
-    def get_color(self):
+    def get_color(self) -> ManimColor:
         """Returns the color of the :class:`~.Mobject`"""
         return self.color
 
     ##
 
-    def save_state(self):
+    def save_state(self) -> Self:
         """Save the current state (position, color & size). Can be restored with :meth:`~.Mobject.restore`."""
         if hasattr(self, "saved_state"):
             # Prevent exponential growth of data
@@ -1835,14 +1886,14 @@ class Mobject:
 
         return self
 
-    def restore(self):
+    def restore(self) -> Self:
         """Restores the state that was previously saved with :meth:`~.Mobject.save_state`."""
         if not hasattr(self, "saved_state") or self.save_state is None:
             raise Exception("Trying to restore without having saved")
         self.become(self.saved_state)
         return self
 
-    def reduce_across_dimension(self, reduce_func, dim: int) -> float:
+    def reduce_across_dimension(self, reduce_func: Callable, dim: int):
         """Find the min or max value from a dimension across all points in this and submobjects."""
         assert dim >= 0 and dim <= 2
         if len(self.submobjects) == 0 and len(self.points) == 0:
@@ -1866,14 +1917,14 @@ class Mobject:
                 rv = reduce_func([value, rv])
         return rv
 
-    def nonempty_submobjects(self):
+    def nonempty_submobjects(self) -> list[Self]:
         return [
             submob
             for submob in self.submobjects
             if len(submob.submobjects) != 0 or len(submob.points) != 0
         ]
 
-    def get_merged_array(self, array_attr) -> np.ndarray:
+    def get_merged_array(self, array_attr: str) -> np.ndarray:
         """Return all of a given attribute from this mobject and all submobjects.
 
         May contain duplicates; the order is in a depth-first (pre-order)
@@ -1884,7 +1935,7 @@ class Mobject:
             result = np.append(result, submob.get_merged_array(array_attr), axis=0)
         return result
 
-    def get_all_points(self) -> np.ndarray:
+    def get_all_points(self) -> Point3D_Array:
         """Return all points from this mobject and all submobjects.
 
         May contain duplicates; the order is in a depth-first (pre-order)
@@ -1894,13 +1945,15 @@ class Mobject:
 
     # Getters
 
-    def get_points_defining_boundary(self):
+    def get_points_defining_boundary(self) -> Point3D_Array:
         return self.get_all_points()
 
-    def get_num_points(self):
+    def get_num_points(self) -> int:
         return len(self.points)
 
-    def get_extremum_along_dim(self, points=None, dim=0, key=0):
+    def get_extremum_along_dim(
+        self, points: Point3D_Array | None = None, dim: int = 0, key: int = 0
+    ) -> np.ndarray | float:
         if points is None:
             points = self.get_points_defining_boundary()
         values = points[:, dim]
@@ -1911,7 +1964,7 @@ class Mobject:
         else:
             return np.max(values)
 
-    def get_critical_point(self, direction):
+    def get_critical_point(self, direction: Vector3) -> Point3D:
         """Picture a box bounding the :class:`~.Mobject`.  Such a box has
         9 'critical points': 4 corners, 4 edge center, the
         center. This returns one of them, along the given direction.
@@ -1940,28 +1993,28 @@ class Mobject:
 
     # Pseudonyms for more general get_critical_point method
 
-    def get_edge_center(self, direction) -> np.ndarray:
-        """Get edge coordinates for certain direction."""
+    def get_edge_center(self, direction: Vector3) -> Point3D:
+        """Get edge Point3Ds for certain direction."""
         return self.get_critical_point(direction)
 
-    def get_corner(self, direction) -> np.ndarray:
-        """Get corner coordinates for certain direction."""
+    def get_corner(self, direction: Vector3) -> Point3D:
+        """Get corner Point3Ds for certain direction."""
         return self.get_critical_point(direction)
 
-    def get_center(self) -> np.ndarray:
-        """Get center coordinates"""
+    def get_center(self) -> Point3D:
+        """Get center Point3Ds"""
         return self.get_critical_point(np.zeros(self.dim))
 
-    def get_center_of_mass(self):
+    def get_center_of_mass(self) -> Point3D:
         return np.apply_along_axis(np.mean, 0, self.get_all_points())
 
-    def get_boundary_point(self, direction):
+    def get_boundary_point(self, direction: Vector3) -> Point3D:
         all_points = self.get_points_defining_boundary()
         index = np.argmax(np.dot(all_points, np.array(direction).T))
         return all_points[index]
 
-    def get_midpoint(self) -> np.ndarray:
-        """Get coordinates of the middle of the path that forms the  :class:`~.Mobject`.
+    def get_midpoint(self) -> Point3D:
+        """Get Point3Ds of the middle of the path that forms the  :class:`~.Mobject`.
 
         Examples
         --------
@@ -1983,74 +2036,74 @@ class Mobject:
         """
         return self.point_from_proportion(0.5)
 
-    def get_top(self) -> np.ndarray:
-        """Get top coordinates of a box bounding the :class:`~.Mobject`"""
+    def get_top(self) -> Point3D:
+        """Get top Point3Ds of a box bounding the :class:`~.Mobject`"""
         return self.get_edge_center(UP)
 
-    def get_bottom(self) -> np.ndarray:
-        """Get bottom coordinates of a box bounding the :class:`~.Mobject`"""
+    def get_bottom(self) -> Point3D:
+        """Get bottom Point3Ds of a box bounding the :class:`~.Mobject`"""
         return self.get_edge_center(DOWN)
 
-    def get_right(self) -> np.ndarray:
-        """Get right coordinates of a box bounding the :class:`~.Mobject`"""
+    def get_right(self) -> Point3D:
+        """Get right Point3Ds of a box bounding the :class:`~.Mobject`"""
         return self.get_edge_center(RIGHT)
 
-    def get_left(self) -> np.ndarray:
-        """Get left coordinates of a box bounding the :class:`~.Mobject`"""
+    def get_left(self) -> Point3D:
+        """Get left Point3Ds of a box bounding the :class:`~.Mobject`"""
         return self.get_edge_center(LEFT)
 
-    def get_zenith(self) -> np.ndarray:
-        """Get zenith coordinates of a box bounding a 3D :class:`~.Mobject`."""
+    def get_zenith(self) -> Point3D:
+        """Get zenith Point3Ds of a box bounding a 3D :class:`~.Mobject`."""
         return self.get_edge_center(OUT)
 
-    def get_nadir(self) -> np.ndarray:
-        """Get nadir (opposite the zenith) coordinates of a box bounding a 3D :class:`~.Mobject`."""
+    def get_nadir(self) -> Point3D:
+        """Get nadir (opposite the zenith) Point3Ds of a box bounding a 3D :class:`~.Mobject`."""
         return self.get_edge_center(IN)
 
-    def length_over_dim(self, dim):
+    def length_over_dim(self, dim: int) -> float:
         """Measure the length of an :class:`~.Mobject` in a certain direction."""
         return self.reduce_across_dimension(
             max,
             dim,
         ) - self.reduce_across_dimension(min, dim)
 
-    def get_coord(self, dim, direction=ORIGIN):
+    def get_coord(self, dim: int, direction: Vector3 = ORIGIN):
         """Meant to generalize ``get_x``, ``get_y`` and ``get_z``"""
         return self.get_extremum_along_dim(dim=dim, key=direction[dim])
 
-    def get_x(self, direction=ORIGIN) -> np.float64:
-        """Returns x coordinate of the center of the :class:`~.Mobject` as ``float``"""
+    def get_x(self, direction: Vector3 = ORIGIN) -> ManimFloat:
+        """Returns x Point3D of the center of the :class:`~.Mobject` as ``float``"""
         return self.get_coord(0, direction)
 
-    def get_y(self, direction=ORIGIN) -> np.float64:
-        """Returns y coordinate of the center of the :class:`~.Mobject` as ``float``"""
+    def get_y(self, direction: Vector3 = ORIGIN) -> ManimFloat:
+        """Returns y Point3D of the center of the :class:`~.Mobject` as ``float``"""
         return self.get_coord(1, direction)
 
-    def get_z(self, direction=ORIGIN) -> np.float64:
-        """Returns z coordinate of the center of the :class:`~.Mobject` as ``float``"""
+    def get_z(self, direction: Vector3 = ORIGIN) -> ManimFloat:
+        """Returns z Point3D of the center of the :class:`~.Mobject` as ``float``"""
         return self.get_coord(2, direction)
 
-    def get_start(self):
+    def get_start(self) -> Point3D:
         """Returns the point, where the stroke that surrounds the :class:`~.Mobject` starts."""
         self.throw_error_if_no_points()
         return np.array(self.points[0])
 
-    def get_end(self):
+    def get_end(self) -> Point3D:
         """Returns the point, where the stroke that surrounds the :class:`~.Mobject` ends."""
         self.throw_error_if_no_points()
         return np.array(self.points[-1])
 
-    def get_start_and_end(self):
+    def get_start_and_end(self) -> tuple[Point3D, Point3D]:
         """Returns starting and ending point of a stroke as a ``tuple``."""
         return self.get_start(), self.get_end()
 
-    def point_from_proportion(self, alpha):
+    def point_from_proportion(self, alpha: float) -> Point3D:
         raise NotImplementedError("Please override in a child class.")
 
-    def proportion_from_point(self, point):
+    def proportion_from_point(self, point: Point3D) -> float:
         raise NotImplementedError("Please override in a child class.")
 
-    def get_pieces(self, n_pieces):
+    def get_pieces(self, n_pieces: float) -> Group:
         template = self.copy()
         template.submobjects = []
         alphas = np.linspace(0, 1, n_pieces + 1)
@@ -2061,7 +2114,7 @@ class Mobject:
             )
         )
 
-    def get_z_index_reference_point(self):
+    def get_z_index_reference_point(self) -> Point3D:
         # TODO, better place to define default z_index_group?
         z_index_group = getattr(self, "z_index_group", self)
         return z_index_group.get_center()
@@ -2076,51 +2129,53 @@ class Mobject:
 
     # Match other mobject properties
 
-    def match_color(self, mobject: Mobject):
+    def match_color(self, mobject: Mobject) -> Self:
         """Match the color with the color of another :class:`~.Mobject`."""
         return self.set_color(mobject.get_color())
 
-    def match_dim_size(self, mobject: Mobject, dim, **kwargs):
+    def match_dim_size(self, mobject: Mobject, dim: int, **kwargs) -> Self:
         """Match the specified dimension with the dimension of another :class:`~.Mobject`."""
         return self.rescale_to_fit(mobject.length_over_dim(dim), dim, **kwargs)
 
-    def match_width(self, mobject: Mobject, **kwargs):
+    def match_width(self, mobject: Mobject, **kwargs) -> Self:
         """Match the width with the width of another :class:`~.Mobject`."""
         return self.match_dim_size(mobject, 0, **kwargs)
 
-    def match_height(self, mobject: Mobject, **kwargs):
+    def match_height(self, mobject: Mobject, **kwargs) -> Self:
         """Match the height with the height of another :class:`~.Mobject`."""
         return self.match_dim_size(mobject, 1, **kwargs)
 
-    def match_depth(self, mobject: Mobject, **kwargs):
+    def match_depth(self, mobject: Mobject, **kwargs) -> Self:
         """Match the depth with the depth of another :class:`~.Mobject`."""
         return self.match_dim_size(mobject, 2, **kwargs)
 
-    def match_coord(self, mobject: Mobject, dim, direction=ORIGIN):
-        """Match the coordinates with the coordinates of another :class:`~.Mobject`."""
+    def match_coord(
+        self, mobject: Mobject, dim: int, direction: Vector3 = ORIGIN
+    ) -> Self:
+        """Match the Point3Ds with the Point3Ds of another :class:`~.Mobject`."""
         return self.set_coord(
             mobject.get_coord(dim, direction),
             dim=dim,
             direction=direction,
         )
 
-    def match_x(self, mobject: Mobject, direction=ORIGIN):
+    def match_x(self, mobject: Mobject, direction=ORIGIN) -> Self:
         """Match x coord. to the x coord. of another :class:`~.Mobject`."""
         return self.match_coord(mobject, 0, direction)
 
-    def match_y(self, mobject: Mobject, direction=ORIGIN):
+    def match_y(self, mobject: Mobject, direction=ORIGIN) -> Self:
         """Match y coord. to the x coord. of another :class:`~.Mobject`."""
         return self.match_coord(mobject, 1, direction)
 
-    def match_z(self, mobject: Mobject, direction=ORIGIN):
+    def match_z(self, mobject: Mobject, direction=ORIGIN) -> Self:
         """Match z coord. to the x coord. of another :class:`~.Mobject`."""
         return self.match_coord(mobject, 2, direction)
 
     def align_to(
         self,
-        mobject_or_point: Mobject | np.ndarray | list,
-        direction=ORIGIN,
-    ):
+        mobject_or_point: Mobject | Point3D,
+        direction: Vector3 = ORIGIN,
+    ) -> Self:
         """Aligns mobject to another :class:`~.Mobject` in a certain direction.
 
         Examples:
@@ -2152,33 +2207,33 @@ class Mobject:
     def __len__(self):
         return len(self.split())
 
-    def get_group_class(self):
+    def get_group_class(self) -> type[Group]:
         return Group
 
     @staticmethod
-    def get_mobject_type_class():
+    def get_mobject_type_class() -> type[Mobject]:
         """Return the base class of this mobject type."""
         return Mobject
 
-    def split(self):
+    def split(self) -> list[Self]:
         result = [self] if len(self.points) > 0 else []
         return result + self.submobjects
 
-    def get_family(self, recurse=True):
-        sub_families = list(map(Mobject.get_family, self.submobjects))
+    def get_family(self, recurse: bool = True) -> list[Self]:
+        sub_families = [x.get_family() for x in self.submobjects]
         all_mobjects = [self] + list(it.chain(*sub_families))
         return remove_list_redundancies(all_mobjects)
 
-    def family_members_with_points(self):
+    def family_members_with_points(self) -> list[Self]:
         return [m for m in self.get_family() if m.get_num_points() > 0]
 
     def arrange(
         self,
-        direction: Sequence[float] = RIGHT,
-        buff=DEFAULT_MOBJECT_TO_MOBJECT_BUFFER,
-        center=True,
+        direction: Vector3 = RIGHT,
+        buff: float = DEFAULT_MOBJECT_TO_MOBJECT_BUFFER,
+        center: bool = True,
         **kwargs,
-    ):
+    ) -> Self:
         """Sorts :class:`~.Mobject` next to each other on screen.
 
         Examples
@@ -2207,14 +2262,14 @@ class Mobject:
         rows: int | None = None,
         cols: int | None = None,
         buff: float | tuple[float, float] = MED_SMALL_BUFF,
-        cell_alignment: np.ndarray = ORIGIN,
+        cell_alignment: Vector3 = ORIGIN,
         row_alignments: str | None = None,  # "ucd"
         col_alignments: str | None = None,  # "lcr"
         row_heights: Iterable[float | None] | None = None,
         col_widths: Iterable[float | None] | None = None,
         flow_order: str = "rd",
         **kwargs,
-    ):
+    ) -> Self:
         """Arrange submobjects in a grid.
 
         Parameters
@@ -2320,15 +2375,15 @@ class Mobject:
 
         # calculate rows cols
         if rows is None and cols is None:
-            cols = ceil(np.sqrt(len(mobs)))
+            cols = math.ceil(math.sqrt(len(mobs)))
             # make the grid as close to quadratic as possible.
             # choosing cols first can results in cols>rows.
             # This is favored over rows>cols since in general
             # the sceene is wider than high.
         if rows is None:
-            rows = ceil(len(mobs) / cols)
+            rows = math.ceil(len(mobs) / cols)
         if cols is None:
-            cols = ceil(len(mobs) / rows)
+            cols = math.ceil(len(mobs) / rows)
         if rows * cols < len(mobs):
             raise ValueError("Too few rows and columns to fit all submobjetcs.")
         # rows and cols are now finally valid.
@@ -2443,24 +2498,28 @@ class Mobject:
         self.move_to(start_pos)
         return self
 
-    def sort(self, point_to_num_func=lambda p: p[0], submob_func=None):
+    def sort(
+        self,
+        point_to_num_func: Callable[[Point3D], ManimInt] = lambda p: p[0],
+        submob_func: Callable[[Mobject], ManimInt] | None = None,
+    ) -> Self:
         """Sorts the list of :attr:`submobjects` by a function defined by ``submob_func``."""
         if submob_func is None:
 
-            def submob_func(m):
+            def submob_func(m: Mobject):
                 return point_to_num_func(m.get_center())
 
         self.submobjects.sort(key=submob_func)
         return self
 
-    def shuffle(self, recursive=False):
+    def shuffle(self, recursive: bool = False) -> None:
         """Shuffles the list of :attr:`submobjects`."""
         if recursive:
             for submob in self.submobjects:
                 submob.shuffle(recursive=True)
         random.shuffle(self.submobjects)
 
-    def invert(self, recursive=False):
+    def invert(self, recursive: bool = False) -> None:
         """Inverts the list of :attr:`submobjects`.
 
         Parameters
@@ -2484,10 +2543,10 @@ class Mobject:
         if recursive:
             for submob in self.submobjects:
                 submob.invert(recursive=True)
-        list.reverse(self.submobjects)
+        self.submobjects.reverse()
 
     # Just here to keep from breaking old scenes.
-    def arrange_submobjects(self, *args, **kwargs):
+    def arrange_submobjects(self, *args, **kwargs) -> Self:
         """Arrange the position of :attr:`submobjects` with a small buffer.
 
         Examples
@@ -2508,11 +2567,11 @@ class Mobject:
         """
         return self.arrange(*args, **kwargs)
 
-    def sort_submobjects(self, *args, **kwargs):
+    def sort_submobjects(self, *args, **kwargs) -> Self:
         """Sort the :attr:`submobjects`"""
         return self.sort(*args, **kwargs)
 
-    def shuffle_submobjects(self, *args, **kwargs):
+    def shuffle_submobjects(self, *args, **kwargs) -> None:
         """Shuffles the order of :attr:`submobjects`
 
         Examples
@@ -2531,7 +2590,7 @@ class Mobject:
         return self.shuffle(*args, **kwargs)
 
     # Alignment
-    def align_data(self, mobject: Mobject, skip_point_alignment: bool = False):
+    def align_data(self, mobject: Mobject, skip_point_alignment: bool = False) -> None:
         """Aligns the data of this mobject with another mobject.
 
         Afterwards, the two mobjects will have the same number of submobjects
@@ -2562,7 +2621,7 @@ class Mobject:
         msg = f"get_point_mobject not implemented for {self.__class__.__name__}"
         raise NotImplementedError(msg)
 
-    def align_points(self, mobject):
+    def align_points(self, mobject: Mobject) -> Self:
         count1 = self.get_num_points()
         count2 = mobject.get_num_points()
         if count1 < count2:
@@ -2571,10 +2630,10 @@ class Mobject:
             mobject.align_points_with_larger(self)
         return self
 
-    def align_points_with_larger(self, larger_mobject):
+    def align_points_with_larger(self, larger_mobject: Mobject):
         raise NotImplementedError("Please override in a child class.")
 
-    def align_submobjects(self, mobject):
+    def align_submobjects(self, mobject: Mobject) -> Self:
         mob1 = self
         mob2 = mobject
         n1 = len(mob1.submobjects)
@@ -2599,14 +2658,14 @@ class Mobject:
                 m2.push_self_into_submobjects()
         return self
 
-    def push_self_into_submobjects(self):
+    def push_self_into_submobjects(self) -> Self:
         copy = self.copy()
         copy.submobjects = []
         self.reset_points()
         self.add(copy)
         return self
 
-    def add_n_more_submobjects(self, n):
+    def add_n_more_submobjects(self, n: int) -> Self | None:
         if n == 0:
             return
 
@@ -2629,10 +2688,16 @@ class Mobject:
         self.submobjects = new_submobs
         return self
 
-    def repeat_submobject(self, submob):
+    def repeat_submobject(self, submob: Mobject) -> Self:
         return submob.copy()
 
-    def interpolate(self, mobject1, mobject2, alpha, path_func=straight_path()):
+    def interpolate(
+        self,
+        mobject1: Mobject,
+        mobject2: Mobject,
+        alpha: float,
+        path_func: PathFuncType = straight_path(),
+    ) -> Self:
         """Turns this :class:`~.Mobject` into an interpolation between ``mobject1``
         and ``mobject2``.
 
@@ -2657,7 +2722,7 @@ class Mobject:
         self.interpolate_color(mobject1, mobject2, alpha)
         return self
 
-    def interpolate_color(self, mobject1, mobject2, alpha):
+    def interpolate_color(self, mobject1: Mobject, mobject2: Mobject, alpha: float):
         raise NotImplementedError("Please override in a child class.")
 
     def become(
@@ -2669,7 +2734,7 @@ class Mobject:
         match_depth: bool = False,
         match_center: bool = False,
         stretch: bool = False,
-    ):
+    ) -> Self:
         """Edit points, colors and submobjects to be identical
         to another :class:`~.Mobject`
 
@@ -2726,7 +2791,7 @@ class Mobject:
             sm1.interpolate_color(sm1, sm2, 1)
         return self
 
-    def match_points(self, mobject: Mobject, copy_submobjects: bool = True):
+    def match_points(self, mobject: Mobject, copy_submobjects: bool = True) -> Self:
         """Edit points, positions, and submobjects to be identical
         to another :class:`~.Mobject`, while keeping the style unchanged.
 
@@ -2748,7 +2813,7 @@ class Mobject:
         return self
 
     # Errors
-    def throw_error_if_no_points(self):
+    def throw_error_if_no_points(self) -> None:
         if self.has_no_points():
             caller_name = sys._getframe(1).f_code.co_name
             raise Exception(
@@ -2760,7 +2825,7 @@ class Mobject:
         self,
         z_index_value: float,
         family: bool = True,
-    ) -> VMobject:
+    ) -> T:
         """Sets the :class:`~.Mobject`'s :attr:`z_index` to the value specified in `z_index_value`.
 
         Parameters
@@ -2799,8 +2864,8 @@ class Mobject:
         self.z_index = z_index_value
         return self
 
-    def set_z_index_by_z_coordinate(self):
-        """Sets the :class:`~.Mobject`'s z coordinate to the value of :attr:`z_index`.
+    def set_z_index_by_z_Point3D(self) -> Self:
+        """Sets the :class:`~.Mobject`'s z Point3D to the value of :attr:`z_index`.
 
         Returns
         -------
@@ -2822,13 +2887,13 @@ class Group(Mobject, metaclass=ConvertToOpenGL):
     be added to the group.
     """
 
-    def __init__(self, *mobjects, **kwargs):
+    def __init__(self, *mobjects, **kwargs) -> None:
         super().__init__(**kwargs)
         self.add(*mobjects)
 
 
 class _AnimationBuilder:
-    def __init__(self, mobject):
+    def __init__(self, mobject) -> None:
         self.mobject = mobject
         self.mobject.generate_target()
 
@@ -2840,7 +2905,7 @@ class _AnimationBuilder:
         self.cannot_pass_args = False
         self.anim_args = {}
 
-    def __call__(self, **kwargs):
+    def __call__(self, **kwargs) -> Self:
         if self.cannot_pass_args:
             raise ValueError(
                 "Animation arguments must be passed before accessing methods and can only be passed once",
@@ -2851,7 +2916,7 @@ class _AnimationBuilder:
 
         return self
 
-    def __getattr__(self, method_name):
+    def __getattr__(self, method_name) -> types.MethodType:
         method = getattr(self.mobject.target, method_name)
         has_overridden_animation = hasattr(method, "_override_animate")
 
@@ -2879,8 +2944,10 @@ class _AnimationBuilder:
 
         return update_target
 
-    def build(self):
-        from ..animation.transform import _MethodAnimation
+    def build(self) -> Animation:
+        from ..animation.transform import (  # is this to prevent circular import?
+            _MethodAnimation,
+        )
 
         if self.overridden_animation:
             anim = self.overridden_animation
@@ -2893,7 +2960,7 @@ class _AnimationBuilder:
         return anim
 
 
-def override_animate(method):
+def override_animate(method) -> types.FunctionType:
     r"""Decorator for overriding method animations.
 
     This allows to specify a method (returning an :class:`~.Animation`)