Add VectorNDLike type aliases (#4068)

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: chopan050

docs/source/contributing/docs/types.rst

@@ -85,14 +85,8 @@ typed as a :class:`~.Point3D`, because it represents a direction along
 which to shift a :class:`~.Mobject`, not a position in space.
 
 As a general rule, if a parameter is called ``direction`` or ``axis``,
-it should be type hinted as some form of :class:`~.VectorND`.
-
-.. warning::
-
-   This is not always true. For example, as of Manim 0.18.0, the direction
-   parameter of the :class:`.Vector` Mobject should be
-   ``Point2DLike | Point3DLike``, as it can also accept ``tuple[float, float]``
-   and ``tuple[float, float, float]``.
+it should be type hinted as some form of :class:`~.VectorND` or
+:class:`~.VectorNDLike`.
 
 Colors
 ------

manim/mobject/geometry/arc.py

@@ -74,7 +74,7 @@ def construct(self):
         Point3D,
         Point3DLike,
         QuadraticSpline,
-        Vector3D,
+        Vector3DLike,
     )
 
 
@@ -99,12 +99,12 @@ class TipableVMobject(VMobject, metaclass=ConvertToOpenGL):
     def __init__(
         self,
         tip_length: float = DEFAULT_ARROW_TIP_LENGTH,
-        normal_vector: Vector3D = OUT,
+        normal_vector: Vector3DLike = OUT,
         tip_style: dict = {},
         **kwargs: Any,
     ) -> None:
         self.tip_length: float = tip_length
-        self.normal_vector: Vector3D = normal_vector
+        self.normal_vector = normal_vector
         self.tip_style: dict = tip_style
         super().__init__(**kwargs)
 

manim/mobject/geometry/line.py

@@ -34,7 +34,7 @@
 
     from typing_extensions import Literal, Self, TypeAlias
 
-    from manim.typing import Point2DLike, Point3D, Point3DLike, Vector3D
+    from manim.typing import Point3D, Point3DLike, Vector2DLike, Vector3D, Vector3DLike
     from manim.utils.color import ParsableManimColor
 
     from ..matrix import Matrix  # Avoid circular import
@@ -175,7 +175,7 @@ def _set_start_and_end_attrs(
     def _pointify(
         self,
         mob_or_point: Mobject | Point3DLike,
-        direction: Vector3D | None = None,
+        direction: Vector3DLike | None = None,
     ) -> Point3D:
         """Transforms a mobject into its corresponding point. Does nothing if a point is passed.
 
@@ -738,7 +738,7 @@ def construct(self):
 
     def __init__(
         self,
-        direction: Point2DLike | Point3DLike = RIGHT,
+        direction: Vector2DLike | Vector3DLike = RIGHT,
         buff: float = 0,
         **kwargs: Any,
     ) -> None:

manim/mobject/graphing/coordinate_systems.py

@@ -64,6 +64,7 @@
         Point3D,
         Point3DLike,
         Vector3D,
+        Vector3DLike,
     )
 
     LineType = TypeVar("LineType", bound=Line)
@@ -353,8 +354,8 @@ def _get_axis_label(
         self,
         label: float | str | VMobject,
         axis: Mobject,
-        edge: Vector3D,
-        direction: Vector3D,
+        edge: Vector3DLike,
+        direction: Vector3DLike,
         buff: float = SMALL_BUFF,
     ) -> Mobject:
         """Gets the label for an axis.
@@ -2432,7 +2433,7 @@ def __init__(
         y_length: float | None = config.frame_height + 2.5,
         z_length: float | None = config.frame_height - 1.5,
         z_axis_config: dict[str, Any] | None = None,
-        z_normal: Vector3D = DOWN,
+        z_normal: Vector3DLike = DOWN,
         num_axis_pieces: int = 20,
         light_source: Point3DLike = 9 * DOWN + 7 * LEFT + 10 * OUT,
         # opengl stuff (?)
@@ -2519,11 +2520,11 @@ def make_func(axis):
     def get_y_axis_label(
         self,
         label: float | str | VMobject,
-        edge: Vector3D = UR,
-        direction: Vector3D = UR,
+        edge: Vector3DLike = UR,
+        direction: Vector3DLike = UR,
         buff: float = SMALL_BUFF,
         rotation: float = PI / 2,
-        rotation_axis: Vector3D = OUT,
+        rotation_axis: Vector3DLike = OUT,
         **kwargs: dict[str, Any],
     ) -> Mobject:
         """Generate a y-axis label.
@@ -2569,11 +2570,11 @@ def construct(self):
     def get_z_axis_label(
         self,
         label: float | str | VMobject,
-        edge: Vector3D = OUT,
-        direction: Vector3D = RIGHT,
+        edge: Vector3DLike = OUT,
+        direction: Vector3DLike = RIGHT,
         buff: float = SMALL_BUFF,
         rotation: float = PI / 2,
-        rotation_axis: Vector3D = RIGHT,
+        rotation_axis: Vector3DLike = RIGHT,
         **kwargs: Any,
     ) -> Mobject:
         """Generate a z-axis label.

manim/mobject/mobject.py

@@ -54,7 +54,7 @@
         Point3D,
         Point3DLike,
         Point3DLike_Array,
-        Vector3D,
+        Vector3DLike,
     )
 
     from ..animation.animation import Animation
@@ -1204,7 +1204,7 @@ def apply_to_family(self, func: Callable[[Mobject], None]) -> None:
         for mob in self.family_members_with_points():
             func(mob)
 
-    def shift(self, *vectors: Vector3D) -> Self:
+    def shift(self, *vectors: Vector3DLike) -> Self:
         """Shift by the given vectors.
 
         Parameters
@@ -1275,14 +1275,14 @@ def construct(self):
         )
         return self
 
-    def rotate_about_origin(self, angle: float, axis: Vector3D = OUT, axes=[]) -> Self:
+    def rotate_about_origin(self, angle: float, axis: Vector3DLike = OUT) -> 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: float,
-        axis: Vector3D = OUT,
+        axis: Vector3DLike = OUT,
         about_point: Point3DLike | None = None,
         **kwargs,
     ) -> Self:
@@ -1350,7 +1350,7 @@ def construct(self):
         )
         return self
 
-    def flip(self, axis: Vector3D = UP, **kwargs) -> Self:
+    def flip(self, axis: Vector3DLike = UP, **kwargs) -> Self:
         """Flips/Mirrors an mobject about its center.
 
         Examples
@@ -1470,7 +1470,7 @@ def apply_points_function_about_point(
         self,
         func: MultiMappingFunction,
         about_point: Point3DLike | None = None,
-        about_edge: Vector3D | None = None,
+        about_edge: Vector3DLike | None = None,
     ) -> Self:
         if about_point is None:
             if about_edge is None:
@@ -1500,7 +1500,7 @@ def center(self) -> Self:
         return self
 
     def align_on_border(
-        self, direction: Vector3D, buff: float = DEFAULT_MOBJECT_TO_EDGE_BUFFER
+        self, direction: Vector3DLike, buff: float = DEFAULT_MOBJECT_TO_EDGE_BUFFER
     ) -> Self:
         """Direction just needs to be a vector pointing towards side or
         corner in the 2d plane.
@@ -1517,7 +1517,7 @@ def align_on_border(
         return self
 
     def to_corner(
-        self, corner: Vector3D = DL, buff: float = DEFAULT_MOBJECT_TO_EDGE_BUFFER
+        self, corner: Vector3DLike = DL, buff: float = DEFAULT_MOBJECT_TO_EDGE_BUFFER
     ) -> Self:
         """Moves this :class:`~.Mobject` to the given corner of the screen.
 
@@ -1545,7 +1545,7 @@ def construct(self):
         return self.align_on_border(corner, buff)
 
     def to_edge(
-        self, edge: Vector3D = LEFT, buff: float = DEFAULT_MOBJECT_TO_EDGE_BUFFER
+        self, edge: Vector3DLike = LEFT, buff: float = DEFAULT_MOBJECT_TO_EDGE_BUFFER
     ) -> Self:
         """Moves this :class:`~.Mobject` to the given edge of the screen,
         without affecting its position in the other dimension.
@@ -1577,12 +1577,12 @@ def construct(self):
     def next_to(
         self,
         mobject_or_point: Mobject | Point3DLike,
-        direction: Vector3D = RIGHT,
+        direction: Vector3DLike = RIGHT,
         buff: float = DEFAULT_MOBJECT_TO_MOBJECT_BUFFER,
-        aligned_edge: Vector3D = ORIGIN,
+        aligned_edge: Vector3DLike = ORIGIN,
         submobject_to_align: Mobject | None = None,
         index_of_submobject_to_align: int | None = None,
-        coor_mask: Vector3D = np.array([1, 1, 1]),
+        coor_mask: Vector3DLike = np.array([1, 1, 1]),
     ) -> Self:
         """Move this :class:`~.Mobject` next to another's :class:`~.Mobject` or Point3D.
 
@@ -1604,13 +1604,18 @@ def construct(self):
                     self.add(d, c, s, t)
 
         """
+        np_direction = np.asarray(direction)
+        np_aligned_edge = np.asarray(aligned_edge)
+
         if isinstance(mobject_or_point, Mobject):
             mob = mobject_or_point
             if index_of_submobject_to_align is not None:
                 target_aligner = mob[index_of_submobject_to_align]
             else:
                 target_aligner = mob
-            target_point = target_aligner.get_critical_point(aligned_edge + direction)
+            target_point = target_aligner.get_critical_point(
+                np_aligned_edge + np_direction
+            )
         else:
             target_point = mobject_or_point
         if submobject_to_align is not None:
@@ -1619,8 +1624,8 @@ def construct(self):
             aligner = self[index_of_submobject_to_align]
         else:
             aligner = self
-        point_to_align = aligner.get_critical_point(aligned_edge - direction)
-        self.shift((target_point - point_to_align + buff * direction) * coor_mask)
+        point_to_align = aligner.get_critical_point(np_aligned_edge - np_direction)
+        self.shift((target_point - point_to_align + buff * np_direction) * coor_mask)
         return self
 
     def shift_onto_screen(self, **kwargs) -> Self:
@@ -1766,22 +1771,22 @@ 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: int, direction: Vector3D = ORIGIN) -> Self:
+    def set_coord(self, value, dim: int, direction: Vector3DLike = 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: float, direction: Vector3D = ORIGIN) -> Self:
+    def set_x(self, x: float, direction: Vector3DLike = 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: float, direction: Vector3D = ORIGIN) -> Self:
+    def set_y(self, y: float, direction: Vector3DLike = 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: float, direction: Vector3D = ORIGIN) -> Self:
+    def set_z(self, z: float, direction: Vector3DLike = ORIGIN) -> Self:
         """Set z value of the center of the :class:`~.Mobject` (``int`` or ``float``)"""
         return self.set_coord(z, 2, direction)
 
@@ -1794,8 +1799,8 @@ def space_out_submobjects(self, factor: float = 1.5, **kwargs) -> Self:
     def move_to(
         self,
         point_or_mobject: Point3DLike | Mobject,
-        aligned_edge: Vector3D = ORIGIN,
-        coor_mask: Vector3D = np.array([1, 1, 1]),
+        aligned_edge: Vector3DLike = ORIGIN,
+        coor_mask: Vector3DLike = np.array([1, 1, 1]),
     ) -> Self:
         """Move center of the :class:`~.Mobject` to certain Point3D."""
         if isinstance(point_or_mobject, Mobject):
@@ -2114,7 +2119,7 @@ def get_extremum_along_dim(
         else:
             return np.max(values)
 
-    def get_critical_point(self, direction: Vector3D) -> Point3D:
+    def get_critical_point(self, direction: Vector3DLike) -> 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.
@@ -2143,11 +2148,11 @@ def get_critical_point(self, direction: Vector3D) -> Point3D:
 
     # Pseudonyms for more general get_critical_point method
 
-    def get_edge_center(self, direction: Vector3D) -> Point3D:
+    def get_edge_center(self, direction: Vector3DLike) -> Point3D:
         """Get edge Point3Ds for certain direction."""
         return self.get_critical_point(direction)
 
-    def get_corner(self, direction: Vector3D) -> Point3D:
+    def get_corner(self, direction: Vector3DLike) -> Point3D:
         """Get corner Point3Ds for certain direction."""
         return self.get_critical_point(direction)
 
@@ -2158,9 +2163,9 @@ def get_center(self) -> Point3D:
     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: Vector3D) -> Point3D:
+    def get_boundary_point(self, direction: Vector3DLike) -> Point3D:
         all_points = self.get_points_defining_boundary()
-        index = np.argmax(np.dot(all_points, np.array(direction).T))
+        index = np.argmax(np.dot(all_points, direction))
         return all_points[index]
 
     def get_midpoint(self) -> Point3D:
@@ -2217,19 +2222,19 @@ def length_over_dim(self, dim: int) -> float:
             dim,
         ) - self.reduce_across_dimension(min, dim)
 
-    def get_coord(self, dim: int, direction: Vector3D = ORIGIN):
+    def get_coord(self, dim: int, direction: Vector3DLike = ORIGIN) -> float:
         """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: Vector3D = ORIGIN) -> float:
+    def get_x(self, direction: Vector3DLike = ORIGIN) -> float:
         """Returns x Point3D of the center of the :class:`~.Mobject` as ``float``"""
         return self.get_coord(0, direction)
 
-    def get_y(self, direction: Vector3D = ORIGIN) -> float:
+    def get_y(self, direction: Vector3DLike = ORIGIN) -> float:
         """Returns y Point3D of the center of the :class:`~.Mobject` as ``float``"""
         return self.get_coord(1, direction)
 
-    def get_z(self, direction: Vector3D = ORIGIN) -> float:
+    def get_z(self, direction: Vector3DLike = ORIGIN) -> float:
         """Returns z Point3D of the center of the :class:`~.Mobject` as ``float``"""
         return self.get_coord(2, direction)
 
@@ -2300,7 +2305,7 @@ def match_depth(self, mobject: Mobject, **kwargs) -> Self:
         return self.match_dim_size(mobject, 2, **kwargs)
 
     def match_coord(
-        self, mobject: Mobject, dim: int, direction: Vector3D = ORIGIN
+        self, mobject: Mobject, dim: int, direction: Vector3DLike = ORIGIN
     ) -> Self:
         """Match the Point3Ds with the Point3Ds of another :class:`~.Mobject`."""
         return self.set_coord(
@@ -2324,7 +2329,7 @@ def match_z(self, mobject: Mobject, direction=ORIGIN) -> Self:
     def align_to(
         self,
         mobject_or_point: Mobject | Point3DLike,
-        direction: Vector3D = ORIGIN,
+        direction: Vector3DLike = ORIGIN,
     ) -> Self:
         """Aligns mobject to another :class:`~.Mobject` in a certain direction.
 
@@ -2431,7 +2436,7 @@ def family_members_with_points(self) -> list[Self]:
 
     def arrange(
         self,
-        direction: Vector3D = RIGHT,
+        direction: Vector3DLike = RIGHT,
         buff: float = DEFAULT_MOBJECT_TO_MOBJECT_BUFFER,
         center: bool = True,
         **kwargs,
@@ -2464,7 +2469,7 @@ def arrange_in_grid(
         rows: int | None = None,
         cols: int | None = None,
         buff: float | tuple[float, float] = MED_SMALL_BUFF,
-        cell_alignment: Vector3D = ORIGIN,
+        cell_alignment: Vector3DLike = ORIGIN,
         row_alignments: str | None = None,  # "ucd"
         col_alignments: str | None = None,  # "lcr"
         row_heights: Iterable[float | None] | None = None,