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

manim/mobject/types/vectorized_mobject.py

@@ -14,12 +14,21 @@ __all__ = [
 
 import itertools as it
 import sys
-import typing
-from typing import Callable, Optional, Sequence, Union
+from typing import (
+    TYPE_CHECKING,
+    Callable,
+    Generator,
+    Hashable,
+    Iterable,
+    Literal,
+    Mapping,
+    Sequence,
+)
 
-import colour
 import numpy as np
+import numpy.typing as npt
 from PIL.Image import Image
+from typing_extensions import Self
 
 from manim.mobject.opengl.opengl_compatibility import ConvertToOpenGL
 from manim.mobject.opengl.opengl_vectorized_mobject import OpenGLVMobject
@@ -38,11 +47,25 @@ from ...utils.bezier import (
     partial_bezier_points,
     proportions_along_bezier_curve_for_point,
 )
-from ...utils.color import BLACK, WHITE, color_to_rgba
-from ...utils.deprecation import deprecated
+from ...utils.color import BLACK, WHITE, ManimColor, ParsableManimColor
 from ...utils.iterables import make_even, resize_array, stretch_array_to_length, tuplify
 from ...utils.space_ops import rotate_vector, shoelace_direction
 
+if TYPE_CHECKING:
+    from manim.typing import (
+        BezierPoints,
+        CubicBezierPoints,
+        ManimFloat,
+        MappingFunction,
+        Point2D,
+        Point3D,
+        Point3D_Array,
+        QuadraticBezierPoints,
+        RGBA_Array_Float,
+        Vector3,
+        Zeros,
+    )
+
 # TODO
 # - Change cubic curve groups to have 4 points instead of 3
 # - Change sub_path idea accordingly
@@ -81,68 +104,78 @@ class VMobject(Mobject):
 
     def __init__(
         self,
-        fill_color=None,
-        fill_opacity=0.0,
-        stroke_color=None,
-        stroke_opacity=1.0,
-        stroke_width=DEFAULT_STROKE_WIDTH,
-        background_stroke_color=BLACK,
-        background_stroke_opacity=1.0,
-        background_stroke_width=0,
-        sheen_factor=0.0,
+        fill_color: ParsableManimColor | None = None,
+        fill_opacity: float = 0.0,
+        stroke_color: ParsableManimColor | None = None,
+        stroke_opacity: float = 1.0,
+        stroke_width: float = DEFAULT_STROKE_WIDTH,
+        background_stroke_color: ParsableManimColor | None = BLACK,
+        background_stroke_opacity: float = 1.0,
+        background_stroke_width: float = 0,
+        sheen_factor: float = 0.0,
         joint_type: LineJointType | None = None,
-        sheen_direction=UL,
-        close_new_points=False,
-        pre_function_handle_to_anchor_scale_factor=0.01,
-        make_smooth_after_applying_functions=False,
-        background_image=None,
-        shade_in_3d=False,
+        sheen_direction: Vector3 = UL,
+        close_new_points: bool = False,
+        pre_function_handle_to_anchor_scale_factor: float = 0.01,
+        make_smooth_after_applying_functions: bool = False,
+        background_image: Image | str | None = None,
+        shade_in_3d: bool = False,
         # TODO, do we care about accounting for varying zoom levels?
-        tolerance_for_point_equality=1e-6,
-        n_points_per_cubic_curve=4,
+        tolerance_for_point_equality: float = 1e-6,
+        n_points_per_cubic_curve: int = 4,
         **kwargs,
     ):
         self.fill_opacity = fill_opacity
         self.stroke_opacity = stroke_opacity
         self.stroke_width = stroke_width
-        self.background_stroke_color = background_stroke_color
-        self.background_stroke_opacity = background_stroke_opacity
-        self.background_stroke_width = background_stroke_width
-        self.sheen_factor = sheen_factor
-        if joint_type is None:
-            joint_type = LineJointType.AUTO
-        self.joint_type = joint_type
-        self.sheen_direction = sheen_direction
-        self.close_new_points = close_new_points
-        self.pre_function_handle_to_anchor_scale_factor = (
+        if background_stroke_color is not None:
+            self.background_stroke_color: ManimColor = ManimColor(
+                background_stroke_color
+            )
+        self.background_stroke_opacity: float = background_stroke_opacity
+        self.background_stroke_width: float = background_stroke_width
+        self.sheen_factor: float = sheen_factor
+        self.joint_type: LineJointType = (
+            LineJointType.AUTO if joint_type is None else joint_type
+        )
+        self.sheen_direction: Vector3 = sheen_direction
+        self.close_new_points: bool = close_new_points
+        self.pre_function_handle_to_anchor_scale_factor: float = (
             pre_function_handle_to_anchor_scale_factor
         )
-        self.make_smooth_after_applying_functions = make_smooth_after_applying_functions
-        self.background_image = background_image
-        self.shade_in_3d = shade_in_3d
-        self.tolerance_for_point_equality = tolerance_for_point_equality
-        self.n_points_per_cubic_curve = n_points_per_cubic_curve
+        self.make_smooth_after_applying_functions: bool = (
+            make_smooth_after_applying_functions
+        )
+        self.background_image: Image | str | None = background_image
+        self.shade_in_3d: bool = shade_in_3d
+        self.tolerance_for_point_equality: float = tolerance_for_point_equality
+        self.n_points_per_cubic_curve: int = n_points_per_cubic_curve
         super().__init__(**kwargs)
+        self.submobjects: list[VMobject]
 
-        if fill_color:
-            self.fill_color = fill_color
-        if stroke_color:
-            self.stroke_color = stroke_color
+        # TODO: Find where color overwrites are happening and remove the color doubling
+        # if "color" in kwargs:
+        #     fill_color = kwargs["color"]
+        #     stroke_color = kwargs["color"]
+        if fill_color is not None:
+            self.fill_color = ManimColor.parse(fill_color)
+        if stroke_color is not None:
+            self.stroke_color = ManimColor.parse(stroke_color)
 
     # OpenGL compatibility
     @property
-    def n_points_per_curve(self):
+    def n_points_per_curve(self) -> int:
         return self.n_points_per_cubic_curve
 
-    def get_group_class(self):
+    def get_group_class(self) -> type[VGroup]:
         return VGroup
 
     @staticmethod
-    def get_mobject_type_class():
+    def get_mobject_type_class() -> type[VMobject]:
         return VMobject
 
     # Colors
-    def init_colors(self, propagate_colors=True):
+    def init_colors(self, propagate_colors: bool = True) -> Self:
         self.set_fill(
             color=self.fill_color,
             opacity=self.fill_opacity,
@@ -172,7 +205,9 @@ class VMobject(Mobject):
 
         return self
 
-    def generate_rgbas_array(self, color, opacity):
+    def generate_rgbas_array(
+        self, color: ManimColor | list[ManimColor], opacity: float | Iterable[float]
+    ) -> RGBA_Array_Float:
         """
         First arg can be either a color, or a tuple/list of colors.
         Likewise, opacity can either be a float, or a tuple of floats.
@@ -180,10 +215,14 @@ class VMobject(Mobject):
         one color was passed in, a second slightly light color
         will automatically be added for the gradient
         """
-        colors = [c if (c is not None) else BLACK for c in tuplify(color)]
-        opacities = [o if (o is not None) else 0 for o in tuplify(opacity)]
-        rgbas = np.array(
-            [color_to_rgba(c, o) for c, o in zip(*make_even(colors, opacities))],
+        colors: list[ManimColor] = [
+            ManimColor(c) if (c is not None) else BLACK for c in tuplify(color)
+        ]
+        opacities: list[float] = [
+            o if (o is not None) else 0.0 for o in tuplify(opacity)
+        ]
+        rgbas: npt.NDArray[RGBA_Array_Float] = np.array(
+            [c.to_rgba_with_alpha(o) for c, o in zip(*make_even(colors, opacities))],
         )
 
         sheen_factor = self.get_sheen_factor()
@@ -194,7 +233,12 @@ class VMobject(Mobject):
             rgbas = np.append(rgbas, light_rgbas, axis=0)
         return rgbas
 
-    def update_rgbas_array(self, array_name, color=None, opacity=None):
+    def update_rgbas_array(
+        self,
+        array_name: str,
+        color: ManimColor | None = None,
+        opacity: float | None = None,
+    ) -> Self:
         rgbas = self.generate_rgbas_array(color, opacity)
         if not hasattr(self, array_name):
             setattr(self, array_name, rgbas)
@@ -217,10 +261,10 @@ class VMobject(Mobject):
 
     def set_fill(
         self,
-        color: str | None = None,
+        color: ParsableManimColor | None = None,
         opacity: float | None = None,
         family: bool = True,
-    ):
+    ) -> Self:
         """Set the fill color and fill opacity of a :class:`VMobject`.
 
         Parameters
@@ -260,18 +304,19 @@ class VMobject(Mobject):
             for submobject in self.submobjects:
                 submobject.set_fill(color, opacity, family)
         self.update_rgbas_array("fill_rgbas", color, opacity)
+        self.fill_rgbas: RGBA_Array_Float
         if opacity is not None:
             self.fill_opacity = opacity
         return self
 
     def set_stroke(
         self,
-        color=None,
-        width=None,
-        opacity=None,
+        color: ParsableManimColor = None,
+        width: float | None = None,
+        opacity: float | None = None,
         background=False,
-        family=True,
-    ):
+        family: bool = True,
+    ) -> Self:
         if family:
             for submobject in self.submobjects:
                 submobject.set_stroke(color, width, opacity, background, family)
@@ -289,29 +334,32 @@ class VMobject(Mobject):
         if opacity is not None:
             setattr(self, opacity_name, opacity)
         if color is not None and background:
-            self.background_stroke_color = color
+            if isinstance(color, (list, tuple)):
+                self.background_stroke_color = color
+            else:
+                self.background_stroke_color = ManimColor(color)
         return self
 
-    def set_background_stroke(self, **kwargs):
+    def set_background_stroke(self, **kwargs) -> Self:
         kwargs["background"] = True
         self.set_stroke(**kwargs)
         return self
 
     def set_style(
         self,
-        fill_color=None,
-        fill_opacity=None,
-        stroke_color=None,
-        stroke_width=None,
-        stroke_opacity=None,
-        background_stroke_color=None,
-        background_stroke_width=None,
-        background_stroke_opacity=None,
-        sheen_factor=None,
-        sheen_direction=None,
-        background_image=None,
-        family=True,
-    ):
+        fill_color: ParsableManimColor | None = None,
+        fill_opacity: float | None = None,
+        stroke_color: ParsableManimColor | None = None,
+        stroke_width: float | None = None,
+        stroke_opacity: float | None = None,
+        background_stroke_color: ParsableManimColor | None = None,
+        background_stroke_width: float | None = None,
+        background_stroke_opacity: float | None = None,
+        sheen_factor: float | None = None,
+        sheen_direction: Vector3 | None = None,
+        background_image: Image | str | None = None,
+        family: bool = True,
+    ) -> Self:
         self.set_fill(color=fill_color, opacity=fill_opacity, family=family)
         self.set_stroke(
             color=stroke_color,
@@ -335,16 +383,17 @@ class VMobject(Mobject):
             self.color_using_background_image(background_image)
         return self
 
-    def get_style(self, simple=False):
+    def get_style(self, simple: bool = False) -> dict:
         ret = {
             "stroke_opacity": self.get_stroke_opacity(),
             "stroke_width": self.get_stroke_width(),
         }
 
+        # TODO: FIX COLORS HERE
         if simple:
-            ret["fill_color"] = colour.rgb2hex(self.get_fill_color().get_rgb())
+            ret["fill_color"] = self.get_fill_color()
             ret["fill_opacity"] = self.get_fill_opacity()
-            ret["stroke_color"] = colour.rgb2hex(self.get_stroke_color().get_rgb())
+            ret["stroke_color"] = self.get_stroke_color()
         else:
             ret["fill_color"] = self.get_fill_colors()
             ret["fill_opacity"] = self.get_fill_opacities()
@@ -358,7 +407,7 @@ class VMobject(Mobject):
 
         return ret
 
-    def match_style(self, vmobject, family=True):
+    def match_style(self, vmobject: VMobject, family: bool = True) -> Self:
         self.set_style(**vmobject.get_style(), family=False)
 
         if family:
@@ -373,18 +422,18 @@ class VMobject(Mobject):
                 sm1.match_style(sm2)
         return self
 
-    def set_color(self, color, family=True):
+    def set_color(self, color: ParsableManimColor, family: bool = True) -> Self:
         self.set_fill(color, family=family)
         self.set_stroke(color, family=family)
         return self
 
-    def set_opacity(self, opacity, family=True):
+    def set_opacity(self, opacity: float, family: bool = True) -> Self:
         self.set_fill(opacity=opacity, family=family)
         self.set_stroke(opacity=opacity, family=family)
         self.set_stroke(opacity=opacity, family=family, background=True)
         return self
 
-    def fade(self, darkness=0.5, family=True):
+    def fade(self, darkness: float = 0.5, family: bool = True) -> Self:
         factor = 1.0 - darkness
         self.set_fill(opacity=factor * self.get_fill_opacity(), family=False)
         self.set_stroke(opacity=factor * self.get_stroke_opacity(), family=False)
@@ -395,13 +444,13 @@ class VMobject(Mobject):
         super().fade(darkness, family)
         return self
 
-    def get_fill_rgbas(self):
+    def get_fill_rgbas(self) -> RGBA_Array_Float | Zeros:
         try:
             return self.fill_rgbas
         except AttributeError:
             return np.zeros((1, 4))
 
-    def get_fill_color(self):
+    def get_fill_color(self) -> ManimColor:
         """
         If there are multiple colors (for gradient)
         this returns the first one
@@ -410,66 +459,71 @@ class VMobject(Mobject):
 
     fill_color = property(get_fill_color, set_fill)
 
-    def get_fill_opacity(self):
+    def get_fill_opacity(self) -> ManimFloat:
         """
         If there are multiple opacities, this returns the
         first
         """
         return self.get_fill_opacities()[0]
 
-    def get_fill_colors(self):
+    # TODO: Does this just do a copy?
+    # TODO: I have the feeling that this function should not return None, does that have any usage ?
+    def get_fill_colors(self) -> list[ManimColor | None]:
         return [
-            colour.Color(rgb=rgba[:3]) if rgba.any() else None
+            ManimColor(rgba[:3]) if rgba.any() else None
             for rgba in self.get_fill_rgbas()
         ]
 
-    def get_fill_opacities(self):
+    def get_fill_opacities(self) -> npt.NDArray[ManimFloat]:
         return self.get_fill_rgbas()[:, 3]
 
-    def get_stroke_rgbas(self, background=False):
+    def get_stroke_rgbas(self, background: bool = False) -> RGBA_Array_float | Zeros:
         try:
             if background:
+                self.background_stroke_rgbas: RGBA_Array_Float
                 rgbas = self.background_stroke_rgbas
             else:
+                self.stroke_rgbas: RGBA_Array_Float
                 rgbas = self.stroke_rgbas
             return rgbas
         except AttributeError:
             return np.zeros((1, 4))
 
-    def get_stroke_color(self, background=False):
+    def get_stroke_color(self, background: bool = False) -> ManimColor | None:
         return self.get_stroke_colors(background)[0]
 
     stroke_color = property(get_stroke_color, set_stroke)
 
-    def get_stroke_width(self, background=False):
+    def get_stroke_width(self, background: bool = False) -> float:
         if background:
+            self.background_stroke_width: float
             width = self.background_stroke_width
         else:
             width = self.stroke_width
             if isinstance(width, str):
                 width = int(width)
-        return max(0, width)
+        return max(0.0, width)
 
-    def get_stroke_opacity(self, background=False):
+    def get_stroke_opacity(self, background: bool = False) -> ManimFloat:
         return self.get_stroke_opacities(background)[0]
 
-    def get_stroke_colors(self, background=False):
+    def get_stroke_colors(self, background: bool = False) -> list[ManimColor | None]:
         return [
-            colour.Color(rgb=rgba[:3]) if rgba.any() else None
+            ManimColor(rgba[:3]) if rgba.any() else None
             for rgba in self.get_stroke_rgbas(background)
         ]
 
-    def get_stroke_opacities(self, background=False):
+    def get_stroke_opacities(self, background: bool = False) -> npt.NDArray[ManimFloat]:
         return self.get_stroke_rgbas(background)[:, 3]
 
-    def get_color(self):
+    def get_color(self) -> ManimColor:
         if np.all(self.get_fill_opacities() == 0):
             return self.get_stroke_color()
         return self.get_fill_color()
 
     color = property(get_color, set_color)
 
-    def set_sheen_direction(self, direction: np.ndarray, family=True):
+    def set_sheen_direction(self, direction: Vector3, family: bool = True) -> Self:
         """Sets the direction of the applied sheen.
 
         Parameters
@@ -494,10 +548,12 @@ class VMobject(Mobject):
             for submob in self.get_family():
                 submob.sheen_direction = direction
         else:
-            self.sheen_direction = direction
+            self.sheen_direction: Vector3 = direction
         return self
 
-    def rotate_sheen_direction(self, angle: float, axis: np.ndarray = OUT, family=True):
+    def rotate_sheen_direction(
+        self, angle: float, axis: Vector3 = OUT, family: bool = True
+    ) -> Self:
         """Rotates the direction of the applied sheen.
 
         Parameters
@@ -528,7 +584,9 @@ class VMobject(Mobject):
             self.sheen_direction = rotate_vector(self.sheen_direction, angle, axis)
         return self
 
-    def set_sheen(self, factor: float, direction: np.ndarray = None, family=True):
+    def set_sheen(
+        self, factor: float, direction: Vector3 | None = None, family: bool = True
+    ) -> Self:
         """Applies a color gradient from a direction.
 
         Parameters
@@ -554,7 +612,7 @@ class VMobject(Mobject):
         if family:
             for submob in self.submobjects:
                 submob.set_sheen(factor, direction, family)
-        self.sheen_factor = factor
+        self.sheen_factor: float = factor
         if direction is not None:
             # family set to false because recursion will
             # already be handled above
@@ -565,13 +623,13 @@ class VMobject(Mobject):
             self.set_fill(self.get_fill_color(), family=family)
         return self
 
-    def get_sheen_direction(self):
+    def get_sheen_direction(self) -> Vector3:
         return np.array(self.sheen_direction)
 
-    def get_sheen_factor(self):
+    def get_sheen_factor(self) -> float:
         return self.sheen_factor
 
-    def get_gradient_start_and_end_points(self):
+    def get_gradient_start_and_end_points(self) -> tuple[Point3D, Point3D]:
         if self.shade_in_3d:
             return get_3d_vmob_gradient_start_and_end_points(self)
         else:
@@ -583,8 +641,8 @@ class VMobject(Mobject):
             offset = np.dot(bases, direction)
             return (c - offset, c + offset)
 
-    def color_using_background_image(self, background_image: Image | str):
-        self.background_image = background_image
+    def color_using_background_image(self, background_image: Image | str) -> Self:
+        self.background_image: Image | str = background_image
         self.set_color(WHITE)
         for submob in self.submobjects:
             submob.color_using_background_image(background_image)
@@ -593,26 +651,28 @@ class VMobject(Mobject):
     def get_background_image(self) -> Image | str:
         return self.background_image
 
-    def match_background_image(self, vmobject):
+    def match_background_image(self, vmobject: VMobject) -> Self:
         self.color_using_background_image(vmobject.get_background_image())
         return self
 
-    def set_shade_in_3d(self, value=True, z_index_as_group=False):
+    def set_shade_in_3d(
+        self, value: bool = True, z_index_as_group: bool = False
+    ) -> Self:
         for submob in self.get_family():
             submob.shade_in_3d = value
             if z_index_as_group:
                 submob.z_index_group = self
         return self
 
-    def set_points(self, points):
-        self.points = np.array(points)
+    def set_points(self, points: Point3D_Array) -> Self:
+        self.points: Point3D_Array = np.array(points)
         return self
 
     def resize_points(
         self,
         new_length: int,
-        resize_func: Callable[[np.ndarray, int], np.ndarray] = resize_array,
-    ):
+        resize_func: Callable[[Point3D, int], Point3D] = resize_array,
+    ) -> Self:
         """Resize the array of anchor points and handles to have
         the specified size.
 
@@ -631,11 +691,11 @@ class VMobject(Mobject):
 
     def set_anchors_and_handles(
         self,
-        anchors1: Sequence[float],
-        handles1: Sequence[float],
-        handles2: Sequence[float],
-        anchors2: Sequence[float],
-    ):
+        anchors1: CubicBezierPoints,
+        handles1: CubicBezierPoints,
+        handles2: CubicBezierPoints,
+        anchors2: CubicBezierPoints,
+    ) -> Self:
         """Given two sets of anchors and handles, process them to set them as anchors
         and handles of the VMobject.
 
@@ -663,17 +723,17 @@ class VMobject(Mobject):
             self.points[index::nppcc] = array
         return self
 
-    def clear_points(self):
+    def clear_points(self) -> None:
         self.points = np.zeros((0, self.dim))
 
-    def append_points(self, new_points):
+    def append_points(self, new_points: Point3D_Array) -> Self:
         # TODO, check that number new points is a multiple of 4?
         # or else that if len(self.points) % 4 == 1, then
         # len(new_points) % 4 == 3?
         self.points = np.append(self.points, new_points, axis=0)
         return self
 
-    def start_new_path(self, point):
+    def start_new_path(self, point: Point3D) -> Self:
         if len(self.points) % 4 != 0:
             # close the open path by appending the last
             # start anchor sufficiently often
@@ -685,23 +745,24 @@ class VMobject(Mobject):
 
     def add_cubic_bezier_curve(
         self,
-        anchor1: np.ndarray,
-        handle1: np.ndarray,
-        handle2: np.ndarray,
-        anchor2,
+        anchor1: CubicBezierPoints,
+        handle1: CubicBezierPoints,
+        handle2: CubicBezierPoints,
+        anchor2: CubicBezierPoints,
     ) -> None:
         # TODO, check the len(self.points) % 4 == 0?
         self.append_points([anchor1, handle1, handle2, anchor2])
 
-    def add_cubic_bezier_curves(self, curves):
+    # what type is curves?
+    def add_cubic_bezier_curves(self, curves) -> None:
         self.append_points(curves.flatten())
 
     def add_cubic_bezier_curve_to(
         self,
-        handle1: np.ndarray,
-        handle2: np.ndarray,
-        anchor: np.ndarray,
-    ):
+        handle1: CubicBezierPoints,
+        handle2: CubicBezierPoints,
+        anchor: CubicBezierPoints,
+    ) -> Self:
         """Add cubic bezier curve to the path.
 
         NOTE : the first anchor is not a parameter as by default the end of the last sub-path!
@@ -730,9 +791,9 @@ class VMobject(Mobject):
 
     def add_quadratic_bezier_curve_to(
         self,
-        handle: np.ndarray,
-        anchor: np.ndarray,
-    ):
+        handle: QuadraticBezierPoints,
+        anchor: QuadraticBezierPoints,
+    ) -> Self:
         """Add Quadratic bezier curve to the path.
 
         Returns
@@ -754,7 +815,7 @@ class VMobject(Mobject):
         )
         return self
 
-    def add_line_to(self, point: np.ndarray):
+    def add_line_to(self, point: Point3D) -> Self:
         """Add a straight line from the last point of VMobject to the given point.
 
         Parameters
@@ -777,7 +838,7 @@ class VMobject(Mobject):
         )
         return self
 
-    def add_smooth_curve_to(self, *points: np.array):
+    def add_smooth_curve_to(self, *points: Point3D) -> Self:
         """Creates a smooth curve from given points and add it to the VMobject. If two points are passed in, the first is interpreted
         as a handle, the second as an anchor.
 
@@ -820,28 +881,28 @@ class VMobject(Mobject):
             self.append_points([last_a2, handle1, handle2, new_anchor])
         return self
 
-    def has_new_path_started(self):
+    def has_new_path_started(self) -> bool:
         nppcc = self.n_points_per_cubic_curve  # 4
         # A new path starting is defined by a control point which is not part of a bezier subcurve.
         return len(self.points) % nppcc == 1
 
-    def get_last_point(self):
+    def get_last_point(self) -> Point3D:
         return self.points[-1]
 
-    def is_closed(self):
+    def is_closed(self) -> bool:
         # TODO use consider_points_equals_2d ?
         return self.consider_points_equals(self.points[0], self.points[-1])
 
-    def close_path(self):
+    def close_path(self) -> None:
         if not self.is_closed():
             self.add_line_to(self.get_subpaths()[-1][0])
 
-    def add_points_as_corners(self, points: np.ndarray) -> VMobject:
+    def add_points_as_corners(self, points: Iterable[Point3D]) -> Iterable[Point3D]:
         for point in points:
             self.add_line_to(point)
         return points
 
-    def set_points_as_corners(self, points: Sequence[float]):
+    def set_points_as_corners(self, points: Point3D_Array) -> Self:
         """Given an array of points, set them as corner of the vmobject.
 
         To achieve that, this algorithm sets handles aligned with the anchors such that the resultant bezier curve will be the segment
@@ -866,12 +927,12 @@ class VMobject(Mobject):
         )
         return self
 
-    def set_points_smoothly(self, points):
+    def set_points_smoothly(self, points: Point3D_Array) -> Self:
         self.set_points_as_corners(points)
         self.make_smooth()
         return self
 
-    def change_anchor_mode(self, mode: str):
+    def change_anchor_mode(self, mode: Literal["jagged", "smooth"]) -> Self:
         """Changes the anchor mode of the bezier curves. This will modify the handles.
 
         There can be only two modes, "jagged", and "smooth".
@@ -881,7 +942,7 @@ class VMobject(Mobject):
         :class:`VMobject`
             ``self``
         """
-        assert mode in ["jagged", "smooth"]
+        assert mode in ["jagged", "smooth"], 'mode must be either "jagged" or "smooth"'
         nppcc = self.n_points_per_cubic_curve
         for submob in self.family_members_with_points():
             subpaths = submob.get_subpaths()
@@ -893,7 +954,7 @@ class VMobject(Mobject):
                 anchors = np.append(subpath[::nppcc], subpath[-1:], 0)
                 if mode == "smooth":
                     h1, h2 = get_smooth_handle_points(anchors)
-                elif mode == "jagged":
+                else:  # mode == "jagged"
                     # The following will make the handles aligned with the anchors, thus making the bezier curve a segment
                     a1 = anchors[:-1]
                     a2 = anchors[1:]
@@ -905,18 +966,18 @@ class VMobject(Mobject):
                 submob.append_points(new_subpath)
         return self
 
-    def make_smooth(self):
+    def make_smooth(self) -> Self:
         return self.change_anchor_mode("smooth")
 
-    def make_jagged(self):
+    def make_jagged(self) -> Self:
         return self.change_anchor_mode("jagged")
 
-    def add_subpath(self, points: np.ndarray):
+    def add_subpath(self, points: Point3D_Array) -> Self:
         assert len(points) % 4 == 0
-        self.points = np.append(self.points, points, axis=0)
+        self.points: Point3D_Array = np.append(self.points, points, axis=0)
         return self
 
-    def append_vectorized_mobject(self, vectorized_mobject):
+    def append_vectorized_mobject(self, vectorized_mobject: VMobject) -> None:
         new_points = list(vectorized_mobject.points)
 
         if self.has_new_path_started():
@@ -925,7 +986,7 @@ class VMobject(Mobject):
             self.points = self.points[:-1]
         self.append_points(new_points)
 
-    def apply_function(self, function):
+    def apply_function(self, function: MappingFunction) -> Self:
         factor = self.pre_function_handle_to_anchor_scale_factor
         self.scale_handle_to_anchor_distances(factor)
         super().apply_function(function)
@@ -937,15 +998,15 @@ class VMobject(Mobject):
     def rotate(
         self,
         angle: float,
-        axis: np.ndarray = OUT,
-        about_point: Sequence[float] | None = None,
+        axis: Vector3 = OUT,
+        about_point: Point3D | None = None,
         **kwargs,
-    ):
+    ) -> Self:
         self.rotate_sheen_direction(angle, axis)
         super().rotate(angle, axis, about_point, **kwargs)
         return self
 
-    def scale_handle_to_anchor_distances(self, factor: float):
+    def scale_handle_to_anchor_distances(self, factor: float) -> Self:
         """If the distance between a given handle point H and its associated
         anchor point A is d, then it changes H to be a distances factor*d
         away from A, but so that the line from A to H doesn't change.
@@ -977,10 +1038,10 @@ class VMobject(Mobject):
         return self
 
     #
-    def consider_points_equals(self, p0, p1):
+    def consider_points_equals(self, p0: Point3D, p1: Point3D) -> bool:
         return np.allclose(p0, p1, atol=self.tolerance_for_point_equality)
 
-    def consider_points_equals_2d(self, p0: np.ndarray, p1: np.ndarray) -> bool:
+    def consider_points_equals_2d(self, p0: Point2D, p1: Point2D) -> bool:
         """Determine if two points are close enough to be considered equal.
 
         This uses the algorithm from np.isclose(), but expanded here for the
@@ -1006,10 +1067,14 @@ class VMobject(Mobject):
         return True
 
     # Information about line
-    def get_cubic_bezier_tuples_from_points(self, points):
-        return np.array(list(self.gen_cubic_bezier_tuples_from_points(points)))
-
-    def gen_cubic_bezier_tuples_from_points(self, points: np.ndarray) -> tuple:
+    def get_cubic_bezier_tuples_from_points(
+        self, points: Point3D_Array
+    ) -> npt.NDArray[Point3D_Array]:
+        return np.array(self.gen_cubic_bezier_tuples_from_points(points))
+
+    def gen_cubic_bezier_tuples_from_points(
+        self, points: Point3D_Array
+    ) -> tuple[Point3D_Array]:
         """Returns the bezier tuples from an array of points.
 
         self.points is a list of the anchors and handles of the bezier curves of the mobject (ie [anchor1, handle1, handle2, anchor2, anchor3 ..])
@@ -1024,23 +1089,23 @@ class VMobject(Mobject):
 
         Returns
         -------
-        typing.Tuple
+        tuple
             Bezier control points.
         """
         nppcc = self.n_points_per_cubic_curve
         remainder = len(points) % nppcc
         points = points[: len(points) - remainder]
         # Basically take every nppcc element.
-        return (points[i : i + nppcc] for i in range(0, len(points), nppcc))
+        return tuple(points[i : i + nppcc] for i in range(0, len(points), nppcc))
 
-    def get_cubic_bezier_tuples(self):
+    def get_cubic_bezier_tuples(self) -> npt.NDArray[Point3D_Array]:
         return self.get_cubic_bezier_tuples_from_points(self.points)
 
     def _gen_subpaths_from_points(
         self,
-        points: np.ndarray,
-        filter_func: typing.Callable[[int], bool],
-    ) -> tuple:
+        points: Point3D_Array,
+        filter_func: Callable[[int], bool],
+    ) -> Generator[Point3D_Array]:
         """Given an array of points defining the bezier curves of the vmobject, return subpaths formed by these points.
         Here, Two bezier curves form a path if at least two of their anchors are evaluated True by the relation defined by filter_func.
 
@@ -1058,7 +1123,7 @@ class VMobject(Mobject):
 
         Returns
         -------
-        typing.Tuple
+        Generator[Point3D_Array]
             subpaths formed by the points.
         """
         nppcc = self.n_points_per_cubic_curve
@@ -1070,7 +1135,7 @@ class VMobject(Mobject):
             if (i2 - i1) >= nppcc
         )
 
-    def get_subpaths_from_points(self, points):
+    def get_subpaths_from_points(self, points: Point3D_Array) -> list[Point3D_Array]:
         return list(
             self._gen_subpaths_from_points(
                 points,
@@ -1078,25 +1143,27 @@ class VMobject(Mobject):
             ),
         )
 
-    def gen_subpaths_from_points_2d(self, points):
+    def gen_subpaths_from_points_2d(
+        self, points: Point3D_Array
+    ) -> Generator[Point3D_Array]:
         return self._gen_subpaths_from_points(
             points,
             lambda n: not self.consider_points_equals_2d(points[n - 1], points[n]),
         )
 
-    def get_subpaths(self) -> tuple:
+    def get_subpaths(self) -> list[Point3D_Array]:
         """Returns subpaths formed by the curves of the VMobject.
 
         Subpaths are ranges of curves with each pair of consecutive curves having their end/start points coincident.
 
         Returns
         -------
-        typing.Tuple
+        list[Point3D_Array]
             subpaths.
         """
         return self.get_subpaths_from_points(self.points)
 
-    def get_nth_curve_points(self, n: int) -> np.ndarray:
+    def get_nth_curve_points(self, n: int) -> Point3D_Array:
         """Returns the points defining the nth curve of the vmobject.
 
         Parameters
@@ -1106,14 +1173,14 @@ class VMobject(Mobject):
 
         Returns
         -------
-        np.ndarray
-            points defininf the nth bezier curve (anchors, handles)
+        Point3D_Array
+            points defining the nth bezier curve (anchors, handles)
         """
         assert n < self.get_num_curves()
         nppcc = self.n_points_per_cubic_curve
         return self.points[nppcc * n : nppcc * (n + 1)]
 
-    def get_nth_curve_function(self, n: int) -> typing.Callable[[float], np.ndarray]:
+    def get_nth_curve_function(self, n: int) -> Callable[[float], Point3D]:
         """Returns the expression of the nth curve.
 
         Parameters
@@ -1123,7 +1190,7 @@ class VMobject(Mobject):
 
         Returns
         -------
-        typing.Callable[float]
+        Callable[float, Point3D]
             expression of the nth bezier curve.
         """
         return bezier(self.get_nth_curve_points(n))
@@ -1132,7 +1199,7 @@ class VMobject(Mobject):
         self,
         n: int,
         sample_points: int | None = None,
-    ) -> np.ndarray:
+    ) -> npt.NDArray[ManimFloat]:
         """Returns the array of short line lengths used for length approximation.
 
         Parameters
@@ -1144,7 +1211,6 @@ class VMobject(Mobject):
 
         Returns
         -------
-        np.ndarray
             The short length-pieces of the nth curve.
         """
         if sample_points is None:
@@ -1185,7 +1251,7 @@ class VMobject(Mobject):
         self,
         n: int,
         sample_points: int | None = None,
-    ) -> tuple[typing.Callable[[float], np.ndarray], float]:
+    ) -> tuple[Callable[[float], Point3D], float]:
         """Returns the expression of the nth curve along with its (approximate) length.
 
         Parameters
@@ -1197,7 +1263,7 @@ class VMobject(Mobject):
 
         Returns
         -------
-        curve : typing.Callable[[float], np.ndarray]
+        curve : Callable[[float], Point3D]
             The function for the nth curve.
         length : :class:`float`
             The length of the nth curve.
@@ -1215,19 +1281,19 @@ class VMobject(Mobject):
         Returns
         -------
         int
-            number of curves. of the vmobject.
+            number of curves of the vmobject.
         """
         nppcc = self.n_points_per_cubic_curve
         return len(self.points) // nppcc
 
     def get_curve_functions(
         self,
-    ) -> typing.Iterable[typing.Callable[[float], np.ndarray]]:
+    ) -> Generator[Callable[[float], Point3D]]:
         """Gets the functions for the curves of the mobject.
 
         Returns
         -------
-        typing.Iterable[typing.Callable[[float], np.ndarray]]
+        Generator[Callable[[float], Point3D]]
             The functions for the curves.
         """
 
@@ -1238,7 +1304,7 @@ class VMobject(Mobject):
 
     def get_curve_functions_with_lengths(
         self, **kwargs
-    ) -> typing.Iterable[tuple[typing.Callable[[float], np.ndarray], float]]:
+    ) -> Generator[tuple[Callable[[float], Point3D], float]]:
         """Gets the functions and lengths of the curves for the mobject.
 
         Parameters
@@ -1248,7 +1314,7 @@ class VMobject(Mobject):
 
         Returns
         -------
-        typing.Iterable[typing.Tuple[typing.Callable[[float], np.ndarray], float]]
+        Generator[tuple[Callable[[float], Point3D], float]]
             The functions and lengths of the curves.
         """
 
@@ -1257,7 +1323,7 @@ class VMobject(Mobject):
         for n in range(num_curves):
             yield self.get_nth_curve_function_with_length(n, **kwargs)
 
-    def point_from_proportion(self, alpha: float) -> np.ndarray:
+    def point_from_proportion(self, alpha: float) -> Point3D:
         """Gets the point at a proportion along the path of the :class:`VMobject`.
 
         Parameters
@@ -1303,7 +1369,7 @@ class VMobject(Mobject):
 
     def proportion_from_point(
         self,
-        point: typing.Iterable[float | int],
+        point: Iterable[float | int],
     ) -> float:
         """Returns the proportion along the path of the :class:`VMobject`
         a particular given point is at.
@@ -1357,7 +1423,7 @@ class VMobject(Mobject):
 
         return alpha
 
-    def get_anchors_and_handles(self) -> typing.Iterable[np.ndarray]:
+    def get_anchors_and_handles(self) -> list[Point3D_Array]:
         """Returns anchors1, handles1, handles2, anchors2,
         where (anchors1[i], handles1[i], handles2[i], anchors2[i])
         will be four points defining a cubic bezier curve
@@ -1365,50 +1431,52 @@ class VMobject(Mobject):
 
         Returns
         -------
-        typing.Iterable[np.ndarray]
+        `list[Point3D_Array]`
             Iterable of the anchors and handles.
         """
         nppcc = self.n_points_per_cubic_curve
         return [self.points[i::nppcc] for i in range(nppcc)]
 
-    def get_start_anchors(self) -> np.ndarray:
+    def get_start_anchors(self) -> Point3D_Array:
         """Returns the start anchors of the bezier curves.
 
         Returns
         -------
-        np.ndarray
+        Point3D_Array
             Starting anchors
         """
-        return self.points[0 :: self.n_points_per_cubic_curve]
+        return self.points[:: self.n_points_per_cubic_curve]
 
-    def get_end_anchors(self) -> np.ndarray:
+    def get_end_anchors(self) -> Point3D_Array:
         """Return the end anchors of the bezier curves.
 
         Returns
         -------
-        np.ndarray
+        Point3D_Array
             Starting anchors
         """
         nppcc = self.n_points_per_cubic_curve
         return self.points[nppcc - 1 :: nppcc]
 
-    def get_anchors(self) -> np.ndarray:
+    def get_anchors(self) -> Point3D_Array:
         """Returns the anchors of the curves forming the VMobject.
 
         Returns
         -------
-        np.ndarray
+        Point3D_Array
             The anchors.
         """
         if self.points.shape[0] == 1:
             return self.points
         return np.array(
-            list(it.chain(*zip(self.get_start_anchors(), self.get_end_anchors()))),
+            tuple(it.chain(*zip(self.get_start_anchors(), self.get_end_anchors()))),
         )
 
-    def get_points_defining_boundary(self):
+    def get_points_defining_boundary(self) -> Point3D_Array:
         # Probably returns all anchors, but this is weird regarding  the name of the method.
-        return np.array(list(it.chain(*(sm.get_anchors() for sm in self.get_family()))))
+        return np.array(
+            tuple(it.chain(*(sm.get_anchors() for sm in self.get_family())))
+        )
 
     def get_arc_length(self, sample_points_per_curve: int | None = None) -> float:
         """Return the approximated length of the whole curve.
@@ -1432,7 +1500,7 @@ class VMobject(Mobject):
         )
 
     # Alignment
-    def align_points(self, vmobject: VMobject):
+    def align_points(self, vmobject: VMobject) -> Self:
         """Adds points to self and vmobject so that they both have the same number of subpaths, with
         corresponding subpaths each containing the same number of points.
 
@@ -1503,7 +1571,7 @@ class VMobject(Mobject):
         vmobject.set_points(new_path2)
         return self
 
-    def insert_n_curves(self, n: int):
+    def insert_n_curves(self, n: int) -> Self:
         """Inserts n curves to the bezier curves of the vmobject.
 
         Parameters
@@ -1527,7 +1595,9 @@ class VMobject(Mobject):
             self.append_points([new_path_point])
         return self
 
-    def insert_n_curves_to_point_list(self, n: int, points: np.ndarray) -> np.ndarray:
+    def insert_n_curves_to_point_list(
+        self, n: int, points: Point3D_Array
+    ) -> npt.NDArray[BezierPoints]:
         """Given an array of k points defining a bezier curves (anchors and handles), returns points defining exactly k + n bezier curves.
 
         Parameters
@@ -1539,7 +1609,6 @@ class VMobject(Mobject):
 
         Returns
         -------
-        np.ndarray
             Points generated.
         """
 
@@ -1582,7 +1651,7 @@ class VMobject(Mobject):
                 )
         return new_points
 
-    def align_rgbas(self, vmobject):
+    def align_rgbas(self, vmobject: VMobject) -> Self:
         attrs = ["fill_rgbas", "stroke_rgbas", "background_stroke_rgbas"]
         for attr in attrs:
             a1 = getattr(self, attr)
@@ -1595,14 +1664,16 @@ class VMobject(Mobject):
                 setattr(self, attr, new_a1)
         return self
 
-    def get_point_mobject(self, center=None):
+    def get_point_mobject(self, center: Point3D | None = None) -> VectorizedPoint:
         if center is None:
             center = self.get_center()
         point = VectorizedPoint(center)
         point.match_style(self)
         return point
 
-    def interpolate_color(self, mobject1, mobject2, alpha):
+    def interpolate_color(
+        self, mobject1: VMobject, mobject2: VMobject, alpha: float
+    ) -> None:
         attrs = [
             "fill_rgbas",
             "stroke_rgbas",
@@ -1626,7 +1697,7 @@ class VMobject(Mobject):
         vmobject: VMobject,
         a: float,
         b: float,
-    ):
+    ) -> Self:
         """Given two bounds a and b, transforms the points of the self vmobject into the points of the vmobject
         passed as parameter with respect to the bounds. Points here stand for control points of the bezier curves (anchors and handles)
 
@@ -1683,7 +1754,7 @@ class VMobject(Mobject):
             )
         return self
 
-    def get_subcurve(self, a: float, b: float) -> VMobject:
+    def get_subcurve(self, a: float, b: float) -> Self:
         """Returns the subcurve of the VMobject between the interval [a, b].
         The curve is a VMobject itself.
 
@@ -1711,7 +1782,7 @@ class VMobject(Mobject):
             vmob.pointwise_become_partial(self, a, b)
         return vmob
 
-    def get_direction(self):
+    def get_direction(self) -> Literal["CW", "CCW"]:
         """Uses :func:`~.space_ops.shoelace_direction` to calculate the direction.
         The direction of points determines in which direction the
         object is drawn, clockwise or counterclockwise.
@@ -1731,7 +1802,7 @@ class VMobject(Mobject):
         """
         return shoelace_direction(self.get_start_anchors())
 
-    def reverse_direction(self):
+    def reverse_direction(self) -> Self:
         """Reverts the point direction by inverting the point order.
 
         Returns
@@ -1756,7 +1827,7 @@ class VMobject(Mobject):
         self.points = self.points[::-1]
         return self
 
-    def force_direction(self, target_direction: str):
+    def force_direction(self, target_direction: Literal["CW", "CCW"]) -> Self:
         """Makes sure that points are either directed clockwise or
         counterclockwise.
 
@@ -1835,21 +1906,16 @@ class VGroup(VMobject, metaclass=ConvertToOpenGL):
         super().__init__(**kwargs)
         self.add(*vmobjects)
 
-    def __repr__(self):
-        return (
-            self.__class__.__name__
-            + "("
-            + ", ".join(str(mob) for mob in self.submobjects)
-            + ")"
-        )
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({", ".join(str(mob) for mob in self.submobjects)})'
 
-    def __str__(self):
+    def __str__(self) -> str:
         return (
             f"{self.__class__.__name__} of {len(self.submobjects)} "
             f"submobject{'s' if len(self.submobjects) > 0 else ''}"
         )
 
-    def add(self, *vmobjects: VMobject):
+    def add(self, *vmobjects: VMobject) -> Self:
         """Checks if all passed elements are an instance of VMobject and then add them to submobjects
 
         Parameters
@@ -1901,21 +1967,21 @@ class VGroup(VMobject, metaclass=ConvertToOpenGL):
             raise TypeError("All submobjects must be of type VMobject")
         return super().add(*vmobjects)
 
-    def __add__(self, vmobject):
+    def __add__(self, vmobject: VMobject) -> Self:
         return VGroup(*self.submobjects, vmobject)
 
-    def __iadd__(self, vmobject):
+    def __iadd__(self, vmobject: VMobject) -> Self:
         return self.add(vmobject)
 
-    def __sub__(self, vmobject):
+    def __sub__(self, vmobject: VMobject) -> Self:
         copy = VGroup(*self.submobjects)
         copy.remove(vmobject)
         return copy
 
-    def __isub__(self, vmobject):
+    def __isub__(self, vmobject: VMobject) -> Self:
         return self.remove(vmobject)
 
-    def __setitem__(self, key: int, value: VMobject | typing.Sequence[VMobject]):
+    def __setitem__(self, key: int, value: VMobject | Sequence[VMobject]) -> None:
         """Override the [] operator for item assignment.
 
         Parameters
@@ -2042,27 +2108,25 @@ class VDict(VMobject, metaclass=ConvertToOpenGL):
     def __init__(
         self,
         mapping_or_iterable: (
-            typing.Mapping[typing.Hashable, VMobject]
-            | typing.Iterable[tuple[typing.Hashable, VMobject]]
+            Mapping[Hashable, VMobject] | Iterable[tuple[Hashable, VMobject]]
         ) = {},
         show_keys: bool = False,
         **kwargs,
-    ):
+    ) -> None:
         super().__init__(**kwargs)
         self.show_keys = show_keys
         self.submob_dict = {}
         self.add(mapping_or_iterable)
 
-    def __repr__(self):
-        return __class__.__name__ + "(" + repr(self.submob_dict) + ")"
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({repr(self.submob_dict)})"
 
     def add(
         self,
         mapping_or_iterable: (
-            typing.Mapping[typing.Hashable, VMobject]
-            | typing.Iterable[tuple[typing.Hashable, VMobject]]
+            Mapping[Hashable, VMobject] | Iterable[tuple[Hashable, VMobject]]
         ),
-    ):
+    ) -> Self:
         """Adds the key-value pairs to the :class:`VDict` object.
 
         Also, it internally adds the value to the `submobjects` :class:`list`
@@ -2090,7 +2154,7 @@ class VDict(VMobject, metaclass=ConvertToOpenGL):
 
         return self
 
-    def remove(self, key: typing.Hashable):
+    def remove(self, key: Hashable) -> Self:
         """Removes the mobject from the :class:`VDict` object having the key `key`
 
         Also, it internally removes the mobject from the `submobjects` :class:`list`
@@ -2118,7 +2182,7 @@ class VDict(VMobject, metaclass=ConvertToOpenGL):
         del self.submob_dict[key]
         return self
 
-    def __getitem__(self, key: typing.Hashable):
+    def __getitem__(self, key: Hashable):
         """Override the [] operator for item retrieval.
 
         Parameters
@@ -2140,7 +2204,7 @@ class VDict(VMobject, metaclass=ConvertToOpenGL):
         submob = self.submob_dict[key]
         return submob
 
-    def __setitem__(self, key: typing.Hashable, value: VMobject):
+    def __setitem__(self, key: Hashable, value: VMobject) -> None:
         """Override the [] operator for item assignment.
 
         Parameters
@@ -2165,7 +2229,7 @@ class VDict(VMobject, metaclass=ConvertToOpenGL):
             self.remove(key)
         self.add([(key, value)])
 
-    def __delitem__(self, key: typing.Hashable):
+    def __delitem__(self, key: Hashable):
         """Override the del operator for deleting an item.
 
         Parameters
@@ -2197,7 +2261,7 @@ class VDict(VMobject, metaclass=ConvertToOpenGL):
         """
         del self.submob_dict[key]
 
-    def __contains__(self, key: typing.Hashable):
+    def __contains__(self, key: Hashable):
         """Override the in operator.
 
         Parameters
@@ -2221,7 +2285,7 @@ class VDict(VMobject, metaclass=ConvertToOpenGL):
         """
         return key in self.submob_dict
 
-    def get_all_submobjects(self):
+    def get_all_submobjects(self) -> list[list]:
         """To get all the submobjects associated with a particular :class:`VDict` object
 
         Returns
@@ -2239,7 +2303,7 @@ class VDict(VMobject, metaclass=ConvertToOpenGL):
         submobjects = self.submob_dict.values()
         return submobjects
 
-    def add_key_value_pair(self, key: typing.Hashable, value: VMobject):
+    def add_key_value_pair(self, key: Hashable, value: VMobject) -> None:
         """A utility function used by :meth:`add` to add the key-value pair
         to :attr:`submob_dict`. Not really meant to be used externally.
 
@@ -2284,14 +2348,14 @@ class VDict(VMobject, metaclass=ConvertToOpenGL):
 class VectorizedPoint(VMobject, metaclass=ConvertToOpenGL):
     def __init__(
         self,
-        location=ORIGIN,
-        color=BLACK,
-        fill_opacity=0,
-        stroke_width=0,
-        artificial_width=0.01,
-        artificial_height=0.01,
+        location: Point3D = ORIGIN,
+        color: ManimColor = BLACK,
+        fill_opacity: float = 0,
+        stroke_width: float = 0,
+        artificial_width: float = 0.01,
+        artificial_height: float = 0.01,
         **kwargs,
-    ):
+    ) -> None:
         self.artificial_width = artificial_width
         self.artificial_height = artificial_height
         super().__init__(
@@ -2305,17 +2369,17 @@ class VectorizedPoint(VMobject, metaclass=ConvertToOpenGL):
     basecls = OpenGLVMobject if config.renderer == RendererType.OPENGL else VMobject
 
     @basecls.width.getter
-    def width(self):
+    def width(self) -> float:
         return self.artificial_width
 
     @basecls.height.getter
-    def height(self):
+    def height(self) -> float:
         return self.artificial_height
 
-    def get_location(self):
+    def get_location(self) -> Point3D:
         return np.array(self.points[0])
 
-    def set_location(self, new_loc):
+    def set_location(self, new_loc: Point3D):
         self.set_points(np.array([new_loc]))
 
 
@@ -2336,7 +2400,7 @@ class CurvesAsSubmobjects(VGroup):
 
     """
 
-    def __init__(self, vmobject, **kwargs):
+    def __init__(self, vmobject: VMobject, **kwargs) -> None:
         super().__init__(**kwargs)
         tuples = vmobject.get_cubic_bezier_tuples()
         for tup in tuples:
@@ -2345,6 +2409,69 @@ class CurvesAsSubmobjects(VGroup):
             part.match_style(vmobject)
             self.add(part)
 
+    def point_from_proportion(self, alpha: float) -> Point3D:
+        """Gets the point at a proportion along the path of the :class:`CurvesAsSubmobjects`.
+
+        Parameters
+        ----------
+        alpha
+            The proportion along the the path of the :class:`CurvesAsSubmobjects`.
+
+        Returns
+        -------
+        :class:`numpy.ndarray`
+            The point on the :class:`CurvesAsSubmobjects`.
+
+        Raises
+        ------
+        :exc:`ValueError`
+            If ``alpha`` is not between 0 and 1.
+        :exc:`Exception`
+            If the :class:`CurvesAsSubmobjects` has no submobjects, or no submobject has points.
+        """
+        if alpha < 0 or alpha > 1:
+            raise ValueError(f"Alpha {alpha} not between 0 and 1.")
+
+        self._throw_error_if_no_submobjects()
+        submobjs_with_pts = self._get_submobjects_with_points()
+
+        if alpha == 1:
+            return submobjs_with_pts[-1].points[-1]
+
+        submobjs_arc_lengths = tuple(
+            part.get_arc_length() for part in submobjs_with_pts
+        )
+
+        total_length = sum(submobjs_arc_lengths)
+        target_length = alpha * total_length
+        current_length = 0
+
+        for i, part in enumerate(submobjs_with_pts):
+            part_length = submobjs_arc_lengths[i]
+            if current_length + part_length >= target_length:
+                residue = (target_length - current_length) / part_length
+                return part.point_from_proportion(residue)
+
+            current_length += part_length
+
+    def _throw_error_if_no_submobjects(self):
+        if len(self.submobjects) == 0:
+            caller_name = sys._getframe(1).f_code.co_name
+            raise Exception(
+                f"Cannot call CurvesAsSubmobjects.{caller_name} for a CurvesAsSubmobject with no submobjects"
+            )
+
+    def _get_submobjects_with_points(self):
+        submobjs_with_pts = tuple(
+            part for part in self.submobjects if len(part.points) > 0
+        )
+        if len(submobjs_with_pts) == 0:
+            caller_name = sys._getframe(1).f_code.co_name
+            raise Exception(
+                f"Cannot call CurvesAsSubmobjects.{caller_name} for a CurvesAsSubmobject whose submobjects have no points"
+            )
+        return submobjs_with_pts
+
 
 class DashedVMobject(VMobject, metaclass=ConvertToOpenGL):
     """A :class:`VMobject` composed of dashes instead of lines.
@@ -2402,14 +2529,14 @@ class DashedVMobject(VMobject, metaclass=ConvertToOpenGL):
 
     def __init__(
         self,
-        vmobject,
-        num_dashes=15,
-        dashed_ratio=0.5,
-        dash_offset=0,
-        color=WHITE,
-        equal_lengths=True,
+        vmobject: VMobject,
+        num_dashes: int = 15,
+        dashed_ratio: float = 0.5,
+        dash_offset: float = 0,
+        color: ManimColor = WHITE,
+        equal_lengths: bool = True,
         **kwargs,
-    ):
+    ) -> None:
         self.dashed_ratio = dashed_ratio
         self.num_dashes = num_dashes
         super().__init__(color=color, **kwargs)