A community-maintained Python framework for creating mathematical animations.
Add typings to `OpenGLMobject` (#3803)
Francisco Manríquez Novoa4641c0a80882
diff --git a/manim/mobject/opengl/opengl_mobject.py b/manim/mobject/opengl/opengl_mobject.pyindex 932b1d0d1..c907c4c2e 100644--- a/manim/mobject/opengl/opengl_mobject.py+++ b/manim/mobject/opengl/opengl_mobject.py@@ -5,9 +5,11 @@ import inspectimport itertools as itimport randomimport sys-from collections.abc import Iterable, Sequence+import types+from collections.abc import Iterable, Iterator, Sequencefrom functools import partialmethod, wrapsfrom math import ceil+from typing import TYPE_CHECKING, Any, Callable, TypeVarimport modernglimport numpy as np@@ -44,10 +46,33 @@ from manim.utils.space_ops import (rotation_matrix_transpose,)+if TYPE_CHECKING:+ import numpy.typing as npt+ from typing_extensions import Self, TypeAlias-def affects_shader_info_id(func):+ from manim.renderer.shader_wrapper import ShaderWrapper+ from manim.typing import (+ ManimFloat,+ MappingFunction,+ MatrixMN,+ PathFuncType,+ Point3D,+ Point3D_Array,+ Vector3D,+ )++ TimeBasedUpdater: TypeAlias = Callable[["Mobject", float], object]+ NonTimeBasedUpdater: TypeAlias = Callable[["Mobject"], object]+ Updater: TypeAlias = NonTimeBasedUpdater | TimeBasedUpdater++ T = TypeVar("T")+++def affects_shader_info_id(+ func: Callable[[OpenGLMobject], OpenGLMobject],+) -> Callable[[OpenGLMobject], OpenGLMobject]:@wraps(func)- def wrapper(self):+ def wrapper(self: OpenGLMobject) -> OpenGLMobject:for mob in self.get_family():func(mob)mob.refresh_shader_wrapper_id()@@ -93,26 +118,26 @@ class OpenGLMobject:def __init__(self,- color=WHITE,- opacity=1,- dim=3, # TODO, get rid of this+ color: ParsableManimColor | Iterable[ParsableManimColor] = WHITE,+ opacity: float = 1,+ dim: int = 3, # TODO, get rid of this# Lighting parameters# Positive gloss up to 1 makes it reflect the light.- gloss=0.0,+ gloss: float = 0.0,# Positive shadow up to 1 makes a side opposite the light darker- shadow=0.0,+ shadow: float = 0.0,# For shaders- render_primitive=moderngl.TRIANGLES,- texture_paths=None,- depth_test=False,+ render_primitive: int = moderngl.TRIANGLES,+ texture_paths: dict[str, str] | None = None,+ depth_test: bool = False,# If true, the mobject will not get rotated according to camera position- is_fixed_in_frame=False,- is_fixed_orientation=False,+ is_fixed_in_frame: bool = False,+ is_fixed_orientation: bool = False,# Must match in attributes of vert shader# Event listener- listen_to_events=False,- model_matrix=None,- should_render=True,+ listen_to_events: bool = False,+ model_matrix: MatrixMN | None = None,+ should_render: bool = True,name: str | None = None,**kwargs,):@@ -199,7 +224,7 @@ class OpenGLMobject:return self._assert_valid_submobjects_internal(submobjects, OpenGLMobject)def _assert_valid_submobjects_internal(- self, submobjects: list[OpenGLMobject], mob_class: type[OpenGLMobject]+ self, submobjects: Iterable[OpenGLMobject], mob_class: type[OpenGLMobject]) -> Self:for i, submob in enumerate(submobjects):if not isinstance(submob, mob_class):@@ -224,14 +249,14 @@ class OpenGLMobject:return self@classmethod- def __init_subclass__(cls, **kwargs):+ def __init_subclass__(cls, **kwargs) -> None:super().__init_subclass__(**kwargs)cls._original__init__ = cls.__init__- def __str__(self):+ def __str__(self) -> str:return self.__class__.__name__- def __repr__(self):+ def __repr__(self) -> str:return str(self.name)def __sub__(self, other):@@ -247,7 +272,7 @@ class OpenGLMobject:return NotImplemented@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@@ -294,14 +319,14 @@ class OpenGLMobject:else:cls.__init__ = cls._original__init__- def init_data(self):+ def init_data(self) -> None:"""Initializes the ``points``, ``bounding_box`` and ``rgbas`` attributes and groups them into self.data.Subclasses can inherit and overwrite this method to extend `self.data`."""self.points = np.zeros((0, 3))self.bounding_box = np.zeros((3, 3))self.rgbas = np.zeros((1, 4))- def init_colors(self):+ def init_colors(self) -> None:"""Initializes the colors.Gets called upon creation"""@@ -315,7 +340,7 @@ class OpenGLMobject:# Typically implemented in subclass, unless purposefully left blankpass- def set(self, **kwargs) -> OpenGLMobject:+ def set(self, **kwargs) -> Self:"""Sets attributes.Mainly to be used along with :attr:`animate` to@@ -349,18 +374,18 @@ class OpenGLMobject:return self- def set_data(self, data):+ def set_data(self, data: dict[str, Any]) -> Self:for key in data:self.data[key] = data[key].copy()return self- def set_uniforms(self, uniforms):+ def set_uniforms(self, uniforms: dict[str, Any]) -> Self:for key in uniforms:self.uniforms[key] = uniforms[key] # Copy?return self@property- def animate(self):+ def animate(self) -> _AnimationBuilder | Self:"""Used to animate the application of a method... warning::@@ -448,7 +473,7 @@ class OpenGLMobject:return _AnimationBuilder(self)@property- def width(self):+ def width(self) -> float:"""The width of the mobject.Returns@@ -482,11 +507,11 @@ class OpenGLMobject:# Only these methods should directly affect points@width.setter- def width(self, value):+ def width(self, value: float) -> None:self.rescale_to_fit(value, 0, stretch=False)@property- def height(self):+ def height(self) -> float:"""The height of the mobject.Returns@@ -519,11 +544,11 @@ class OpenGLMobject:return self.length_over_dim(1)@height.setter- def height(self, value):+ def height(self, value: float) -> None:self.rescale_to_fit(value, 1, stretch=False)@property- def depth(self):+ def depth(self) -> float:"""The depth of the mobject.Returns@@ -540,7 +565,7 @@ class OpenGLMobject:return self.length_over_dim(2)@depth.setter- def depth(self, value):+ def depth(self, value: float) -> None:self.rescale_to_fit(value, 2, stretch=False)def resize_points(self, new_length, resize_func=resize_array):@@ -549,7 +574,7 @@ class OpenGLMobject:self.refresh_bounding_box()return self- def set_points(self, points):+ def set_points(self, points: Point3D_Array) -> Self:if len(points) == len(self.points):self.points[:] = pointselif isinstance(points, np.ndarray):@@ -559,23 +584,26 @@ class OpenGLMobject:self.refresh_bounding_box()return self- def apply_over_attr_arrays(self, func):+ def apply_over_attr_arrays(+ self, func: Callable[[npt.NDArray[T]], npt.NDArray[T]]+ ) -> Self:+ # TODO: OpenGLMobject.get_array_attrs() doesn't even exist!for attr in self.get_array_attrs():setattr(self, attr, func(getattr(self, attr)))return self- def append_points(self, new_points):+ def append_points(self, new_points: Point3D_Array) -> Self:self.points = np.vstack([self.points, new_points])self.refresh_bounding_box()return self- def reverse_points(self):+ def reverse_points(self) -> Self:for mob in self.get_family():for key in mob.data:mob.data[key] = mob.data[key][::-1]return self- def get_midpoint(self) -> np.ndarray:+ def get_midpoint(self) -> Point3D:"""Get coordinates of the middle of the path that forms the :class:`~.OpenGLMobject`.Examples@@ -600,11 +628,11 @@ class OpenGLMobject:def apply_points_function(self,- func,- about_point=None,- about_edge=ORIGIN,- works_on_bounding_box=False,- ):+ func: MappingFunction,+ about_point: Point3D | None = None,+ about_edge: Vector3D | None = ORIGIN,+ works_on_bounding_box: bool = False,+ ) -> Self:if about_point is None and about_edge is not None:about_point = self.get_bounding_box_point(about_edge)@@ -630,7 +658,7 @@ class OpenGLMobject:# Others related to points- def match_points(self, mobject):+ def match_points(self, mobject: OpenGLMobject) -> Self:"""Edit points, positions, and submobjects to be identicalto another :class:`~.OpenGLMobject`, while keeping the style unchanged.@@ -648,29 +676,31 @@ class OpenGLMobject:self.wait(0.5)"""self.set_points(mobject.points)+ return self- def clear_points(self):+ def clear_points(self) -> Self:self.points = np.empty((0, 3))+ return self- def get_num_points(self):+ def get_num_points(self) -> int:return len(self.points)- def get_all_points(self):+ def get_all_points(self) -> Point3D_Array:if self.submobjects:return np.vstack([sm.points for sm in self.get_family()])else:return self.points- def has_points(self):+ def has_points(self) -> bool:return self.get_num_points() > 0- def get_bounding_box(self):+ def get_bounding_box(self) -> npt.NDArray[float]:if self.needs_new_bounding_box:self.bounding_box = self.compute_bounding_box()self.needs_new_bounding_box = Falsereturn self.bounding_box- def compute_bounding_box(self):+ def compute_bounding_box(self) -> npt.NDArray[float]:all_points = np.vstack([self.points,@@ -690,7 +720,9 @@ class OpenGLMobject:mids = (mins + maxs) / 2return np.array([mins, mids, maxs])- def refresh_bounding_box(self, recurse_down=False, recurse_up=True):+ def refresh_bounding_box(+ self, recurse_down: bool = False, recurse_up: bool = True+ ) -> Self:for mob in self.get_family(recurse_down):mob.needs_new_bounding_box = Trueif recurse_up:@@ -698,7 +730,7 @@ class OpenGLMobject:parent.refresh_bounding_box()return self- def is_point_touching(self, point, buff=MED_SMALL_BUFF):+ def is_point_touching(self, point: Point3D, buff: float = MED_SMALL_BUFF) -> bool:bb = self.get_bounding_box()mins = bb[0] - buffmaxs = bb[2] + buff@@ -706,22 +738,22 @@ class OpenGLMobject:# Family matters- def __getitem__(self, value):+ def __getitem__(self, value: int | slice) -> OpenGLMobject:if isinstance(value, slice):GroupClass = self.get_group_class()return GroupClass(*self.split().__getitem__(value))return self.split().__getitem__(value)- def __iter__(self):+ def __iter__(self) -> Iterator[OpenGLMobject]:return iter(self.split())- def __len__(self):+ def __len__(self) -> int:return len(self.split())- def split(self):+ def split(self) -> Sequence[OpenGLMobject]:return self.submobjects- def assemble_family(self):+ def assemble_family(self) -> Self:sub_families = (sm.get_family() for sm in self.submobjects)self.family = [self, *uniq_chain(*sub_families)]self.refresh_has_updater_status()@@ -730,18 +762,16 @@ class OpenGLMobject:parent.assemble_family()return self- def get_family(self, recurse=True):+ def get_family(self, recurse: bool = True) -> Sequence[OpenGLMobject]:if recurse and hasattr(self, "family"):return self.familyelse:return [self]- def family_members_with_points(self):+ def family_members_with_points(self) -> Sequence[OpenGLMobject]:return [m for m in self.get_family() if m.has_points()]- def add(- self, *mobjects: OpenGLMobject, update_parent: bool = False- ) -> OpenGLMobject:+ def add(self, *mobjects: OpenGLMobject, update_parent: bool = False) -> Self:"""Add mobjects as submobjects.The mobjects are added to :attr:`submobjects`.@@ -826,7 +856,9 @@ class OpenGLMobject:self.assemble_family()return self- def insert(self, index: int, mobject: OpenGLMobject, update_parent: bool = False):+ def insert(+ self, index: int, mobject: OpenGLMobject, update_parent: bool = False+ ) -> Self:"""Inserts a mobject at a specific position into self.submobjectsEffectively just calls ``self.submobjects.insert(index, mobject)``,@@ -858,9 +890,7 @@ class OpenGLMobject:self.assemble_family()return self- def remove(- self, *mobjects: OpenGLMobject, update_parent: bool = False- ) -> OpenGLMobject:+ def remove(self, *mobjects: OpenGLMobject, update_parent: bool = False) -> Self:"""Remove :attr:`submobjects`.The mobjects are removed from :attr:`submobjects`, if they exist.@@ -894,7 +924,7 @@ class OpenGLMobject:self.assemble_family()return self- def add_to_back(self, *mobjects: OpenGLMobject) -> OpenGLMobject:+ def add_to_back(self, *mobjects: OpenGLMobject) -> Self:# NOTE: is the note true OpenGLMobjects?"""Add all passed mobjects to the back of the submobjects.@@ -943,7 +973,7 @@ class OpenGLMobject:self.submobjects = list_update(mobjects, self.submobjects)return self- def replace_submobject(self, index, new_submob):+ def replace_submobject(self, index: int, new_submob: OpenGLMobject) -> Self:self._assert_valid_submobjects([new_submob])old_submob = self.submobjects[index]if self in old_submob.parents:@@ -954,7 +984,9 @@ class OpenGLMobject:# Submobject organization- def arrange(self, direction=RIGHT, center=True, **kwargs):+ def arrange(+ self, direction: Vector3D = RIGHT, center: bool = True, **kwargs+ ) -> Self:"""Sorts :class:`~.OpenGLMobject` next to each other on screen.Examples@@ -983,14 +1015,14 @@ class OpenGLMobject:rows: int | None = None,cols: int | None = None,buff: float | tuple[float, float] = MED_SMALL_BUFF,- cell_alignment: np.ndarray = ORIGIN,+ cell_alignment: Vector3D = 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,+ row_heights: Sequence[float | None] | None = None,+ col_widths: Sequence[float | None] | None = None,flow_order: str = "rd",**kwargs,- ) -> OpenGLMobject:+ ) -> Self:"""Arrange submobjects in a grid.Parameters@@ -1086,16 +1118,27 @@ class OpenGLMobject:start_pos = self.get_center()# get cols / rows values if given (implicitly)- def init_size(num, alignments, sizes):+ def init_size(+ num: int | None,+ alignments: str | None,+ sizes: Sequence[float | None] | None,+ name: str,+ ) -> int:if num is not None:return numif alignments is not None:return len(alignments)if sizes is not None:return len(sizes)+ raise ValueError(+ f"At least one of the following parameters: '{name}s', "+ f"'{name}_alignments' or "+ f"'{name}_{'widths' if name == 'col' else 'heights'}', "+ "must not be None"+ )- cols = init_size(cols, col_alignments, col_widths)- rows = init_size(rows, row_alignments, row_heights)+ cols = init_size(cols, col_alignments, col_widths, "col")+ rows = init_size(rows, row_alignments, row_heights, "row")# calculate rows colsif rows is None and cols is None:@@ -1119,16 +1162,19 @@ class OpenGLMobject:buff_x = buff_y = buff# Initialize alignments correctly- def init_alignments(alignments, num, mapping, name, dir):- if alignments is None:+ def init_alignments(+ str_alignments: str | None,+ num: int,+ mapping: dict[str, Vector3D],+ name: str,+ direction: Vector3D,+ ) -> Sequence[Vector3D]:+ if str_alignments is None:# Use cell_alignment as fallback- return [cell_alignment * dir] * num- if len(alignments) != num:+ return [cell_alignment * direction] * num+ if len(str_alignments) != num:raise ValueError(f"{name}_alignments has a mismatching size.")- alignments = list(alignments)- for i in range(num):- alignments[i] = mapping[alignments[i]]- return alignments+ return [mapping[letter] for letter in str_alignments]row_alignments = init_alignments(row_alignments,@@ -1164,11 +1210,12 @@ class OpenGLMobject:# Reverse row_alignments and row_heights. Necessary since the# grid filling is handled bottom up for simplicity reasons.- def reverse(maybe_list):+ def reverse(maybe_list: Sequence[Any] | None) -> Sequence[Any] | None:if maybe_list is not None:maybe_list = list(maybe_list)maybe_list.reverse()return maybe_list+ return Nonerow_alignments = reverse(row_alignments)row_heights = reverse(row_heights)@@ -1189,7 +1236,12 @@ class OpenGLMobject:]# Initialize row_heights / col_widths correctly using measurements as fallback- def init_sizes(sizes, num, measures, name):+ def init_sizes(+ sizes: Sequence[float | None] | None,+ num: int,+ measures: Sequence[float],+ name: str,+ ) -> Sequence[float]:if sizes is None:sizes = [None] * numif len(sizes) != num:@@ -1222,7 +1274,9 @@ class OpenGLMobject:self.move_to(start_pos)return self- def get_grid(self, n_rows, n_cols, height=None, **kwargs):+ def get_grid(+ self, n_rows: int, n_cols: int, height: float | None = None, **kwargs+ ) -> OpenGLGroup:"""Returns a new mobject containing multiple copies of this onearranged in a grid@@ -1233,11 +1287,15 @@ class OpenGLMobject:grid.set_height(height)return grid- def duplicate(self, n: int):- """Returns an :class:`~.OpenGLVGroup` containing ``n`` copies of the mobject."""+ def duplicate(self, n: int) -> OpenGLGroup:+ """Returns an :class:`~.OpenGLGroup` containing ``n`` copies of the mobject."""return self.get_group_class()(*[self.copy() for _ in range(n)])- def sort(self, point_to_num_func=lambda p: p[0], submob_func=None):+ def sort(+ self,+ point_to_num_func: Callable[[Point3D], float] = lambda p: p[0],+ submob_func: Callable[[OpenGLMobject], Any] | None = None,+ ) -> Self:"""Sorts the list of :attr:`submobjects` by a function defined by ``submob_func``."""if submob_func is not None:self.submobjects.sort(key=submob_func)@@ -1245,7 +1303,7 @@ class OpenGLMobject:self.submobjects.sort(key=lambda m: point_to_num_func(m.get_center()))return self- def shuffle(self, recurse=False):+ def shuffle(self, recurse: bool = False) -> Self:"""Shuffles the order of :attr:`submobjects`Examples@@ -1268,7 +1326,7 @@ class OpenGLMobject:self.assemble_family()return self- def invert(self, recursive=False):+ def invert(self, recursive: bool = False) -> Self:"""Inverts the list of :attr:`submobjects`.Parameters@@ -1297,7 +1355,7 @@ class OpenGLMobject:# Copying- def copy(self, shallow: bool = False):+ def copy(self, shallow: bool = False) -> OpenGLMobject:"""Create and return an identical copy of the :class:`OpenGLMobject` including all:attr:`submobjects`.@@ -1355,14 +1413,14 @@ class OpenGLMobject:# setattr(copy_mobject, attr, value.copy())return copy_mobject- def deepcopy(self):+ def deepcopy(self) -> OpenGLMobject:parents = self.parentsself.parents = []result = copy.deepcopy(self)self.parents = parentsreturn result- def generate_target(self, use_deepcopy: bool = False):+ def generate_target(self, use_deepcopy: bool = False) -> OpenGLMobject:self.target = None # Prevent exponential explosionif use_deepcopy:self.target = self.deepcopy()@@ -1370,7 +1428,7 @@ class OpenGLMobject:self.target = self.copy()return self.target- def save_state(self, use_deepcopy: bool = False):+ def save_state(self, use_deepcopy: bool = False) -> Self:"""Save the current state (position, color & size). Can be restored with :meth:`~.OpenGLMobject.restore`."""if hasattr(self, "saved_state"):# Prevent exponential growth of data@@ -1381,7 +1439,7 @@ class OpenGLMobject:self.saved_state = self.copy()return self- def restore(self):+ def restore(self) -> Self:"""Restores the state that was previously saved with :meth:`~.OpenGLMobject.save_state`."""if not hasattr(self, "saved_state") or self.save_state is None:raise Exception("Trying to restore without having saved")@@ -1390,13 +1448,13 @@ class OpenGLMobject:# Updating- def init_updaters(self):+ def init_updaters(self) -> None:self.time_based_updaters = []self.non_time_updaters = []self.has_updaters = Falseself.updating_suspended = False- def update(self, dt=0, recurse=True):+ def update(self, dt: float = 0, recurse: bool = True) -> Self:if not self.has_updaters or self.updating_suspended:return selffor updater in self.time_based_updaters:@@ -1408,19 +1466,24 @@ class OpenGLMobject:submob.update(dt, recurse)return self- def get_time_based_updaters(self):+ def get_time_based_updaters(self) -> Sequence[TimeBasedUpdater]:return self.time_based_updaters- def has_time_based_updater(self):+ def has_time_based_updater(self) -> bool:return len(self.time_based_updaters) > 0- def get_updaters(self):+ def get_updaters(self) -> Sequence[Updater]:return self.time_based_updaters + self.non_time_updaters- def get_family_updaters(self):+ def get_family_updaters(self) -> Sequence[Updater]:return list(it.chain(*(sm.get_updaters() for sm in self.get_family())))- def add_updater(self, update_function, index=None, call_updater=False):+ def add_updater(+ self,+ update_function: Updater,+ index: int | None = None,+ call_updater: bool = False,+ ) -> Self:if "dt" in inspect.signature(update_function).parameters:updater_list = self.time_based_updaterselse:@@ -1436,14 +1499,14 @@ class OpenGLMobject:self.update()return self- def remove_updater(self, update_function):+ def remove_updater(self, update_function: Updater) -> Self:for updater_list in [self.time_based_updaters, self.non_time_updaters]:while update_function in updater_list:updater_list.remove(update_function)self.refresh_has_updater_status()return self- def clear_updaters(self, recurse=True):+ def clear_updaters(self, recurse: bool = True) -> Self:self.time_based_updaters = []self.non_time_updaters = []self.refresh_has_updater_status()@@ -1452,20 +1515,20 @@ class OpenGLMobject:submob.clear_updaters()return self- def match_updaters(self, mobject):+ def match_updaters(self, mobject: OpenGLMobject) -> Self:self.clear_updaters()for updater in mobject.get_updaters():self.add_updater(updater)return self- def suspend_updating(self, recurse=True):+ def suspend_updating(self, recurse: bool = True) -> Self:self.updating_suspended = Trueif recurse:for submob in self.submobjects:submob.suspend_updating(recurse)return self- def resume_updating(self, recurse=True, call_updater=True):+ def resume_updating(self, recurse: bool = True, call_updater: bool = True) -> Self:self.updating_suspended = Falseif recurse:for submob in self.submobjects:@@ -1476,13 +1539,13 @@ class OpenGLMobject:self.update(dt=0, recurse=recurse)return self- def refresh_has_updater_status(self):+ def refresh_has_updater_status(self) -> Self:self.has_updaters = any(mob.get_updaters() for mob in self.get_family())return self# Transforming operations- def shift(self, vector):+ def shift(self, vector: Vector3D) -> Self:self.apply_points_function(lambda points: points + vector,about_edge=None,@@ -1496,7 +1559,7 @@ class OpenGLMobject:about_point: Sequence[float] | None = None,about_edge: Sequence[float] = ORIGIN,**kwargs,- ) -> OpenGLMobject:+ ) -> Self:r"""Scale the size by a factor.Default behavior is to scale about the center of the mobject.@@ -1552,7 +1615,7 @@ class OpenGLMobject:)return self- def stretch(self, factor, dim, **kwargs):+ def stretch(self, factor: float, dim: int, **kwargs) -> Self:def func(points):points[:, dim] *= factorreturn points@@ -1560,16 +1623,16 @@ class OpenGLMobject:self.apply_points_function(func, works_on_bounding_box=True, **kwargs)return self- def rotate_about_origin(self, angle, axis=OUT):+ def rotate_about_origin(self, angle: float, axis: Vector3D = OUT) -> Self:return self.rotate(angle, axis, about_point=ORIGIN)def rotate(self,- angle,- axis=OUT,+ angle: float,+ axis: Vector3D = OUT,about_point: Sequence[float] | None = None,**kwargs,- ):+ ) -> Self:"""Rotates the :class:`~.OpenGLMobject` about a certain point."""rot_matrix_T = rotation_matrix_transpose(angle, axis)self.apply_points_function(@@ -1579,7 +1642,7 @@ class OpenGLMobject:)return self- def flip(self, axis=UP, **kwargs):+ def flip(self, axis: Vector3D = UP, **kwargs) -> Self:"""Flips/Mirrors an mobject about its center.Examples@@ -1598,7 +1661,7 @@ class OpenGLMobject:"""return self.rotate(TAU / 2, axis, **kwargs)- def apply_function(self, function, **kwargs):+ def apply_function(self, function: MappingFunction, **kwargs) -> Self:# Default to applying matrix about the origin, not mobjects centerif len(kwargs) == 0:kwargs["about_point"] = ORIGIN@@ -1607,16 +1670,16 @@ class OpenGLMobject:)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: MatrixMN, **kwargs) -> Self:# Default to applying matrix about the origin, not mobjects centerif ("about_point" not in kwargs) and ("about_edge" not in kwargs):kwargs["about_point"] = ORIGIN@@ -1628,7 +1691,9 @@ class OpenGLMobject:)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:`OpenGLMobject`.The x and y coordinates correspond to the real and imaginary parts respectively.@@ -1662,7 +1727,7 @@ class OpenGLMobject:return self.apply_function(R3_func)- def hierarchical_model_matrix(self):+ def hierarchical_model_matrix(self) -> MatrixMN:if self.parent is None:return self.model_matrix@@ -1673,7 +1738,12 @@ class OpenGLMobject:current_object = current_object.parentreturn np.linalg.multi_dot(list(reversed(model_matrices)))- def wag(self, direction=RIGHT, axis=DOWN, wag_factor=1.0):+ def wag(+ self,+ direction: Vector3D = RIGHT,+ axis: Vector3D = 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)@@ -1690,12 +1760,16 @@ class OpenGLMobject:# Positioning methods- def center(self):+ def center(self) -> Self:"""Moves the mobject to the center of the Scene."""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: Vector3D,+ buff: float = DEFAULT_MOBJECT_TO_EDGE_BUFFER,+ ) -> Self:"""Direction just needs to be a vector pointing towards side orcorner in the 2d plane.@@ -1711,22 +1785,30 @@ class OpenGLMobject:self.shift(shift_val)return self- def to_corner(self, corner=LEFT + DOWN, buff=DEFAULT_MOBJECT_TO_EDGE_BUFFER):+ def to_corner(+ self,+ corner: Vector3D = LEFT + DOWN,+ 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: Vector3D = 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]),- ):+ mobject_or_point: OpenGLMobject | Point3D,+ direction: Vector3D = RIGHT,+ buff: float = DEFAULT_MOBJECT_TO_MOBJECT_BUFFER,+ aligned_edge: Vector3D = ORIGIN,+ submobject_to_align: OpenGLMobject | None = None,+ index_of_submobject_to_align: int | None = None,+ coor_mask: Point3D = np.array([1, 1, 1]),+ ) -> Self:"""Move this :class:`~.OpenGLMobject` next to another's :class:`~.OpenGLMobject` or coordinate.Examples@@ -1768,7 +1850,7 @@ class OpenGLMobject: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))@@ -1779,7 +1861,7 @@ class OpenGLMobject:self.to_edge(vect, **kwargs)return self- def is_off_screen(self):+ def is_off_screen(self) -> bool:if self.get_left()[0] > config.frame_x_radius:return Trueif self.get_right()[0] < config.frame_x_radius:@@ -1790,10 +1872,12 @@ class OpenGLMobject:return Truereturn 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@@ -1803,7 +1887,7 @@ class OpenGLMobject:self.scale(length / old_length, **kwargs)return self- def stretch_to_fit_width(self, width, **kwargs):+ def stretch_to_fit_width(self, width: float, **kwargs) -> Self:"""Stretches the :class:`~.OpenGLMobject` to fit a width, not keeping height/depth proportional.Returns@@ -1828,15 +1912,15 @@ class OpenGLMobject:"""return self.rescale_to_fit(width, 0, stretch=True, **kwargs)- def stretch_to_fit_height(self, height, **kwargs):+ def stretch_to_fit_height(self, height: float, **kwargs) -> Self:"""Stretches the :class:`~.OpenGLMobject` to fit a height, not keeping width/height proportional."""return self.rescale_to_fit(height, 1, stretch=True, **kwargs)- def stretch_to_fit_depth(self, depth, **kwargs):+ def stretch_to_fit_depth(self, depth: float, **kwargs) -> Self:"""Stretches the :class:`~.OpenGLMobject` to fit a depth, not keeping width/height proportional."""return self.rescale_to_fit(depth, 1, stretch=True, **kwargs)- def set_width(self, width, stretch=False, **kwargs):+ def set_width(self, width: float, stretch: bool = False, **kwargs) -> Self:"""Scales the :class:`~.OpenGLMobject` to fit a width while keeping height/depth proportional.Returns@@ -1863,38 +1947,38 @@ class OpenGLMobject:scale_to_fit_width = set_width- def set_height(self, height, stretch=False, **kwargs):+ def set_height(self, height: float, stretch: bool = False, **kwargs) -> Self:"""Scales the :class:`~.OpenGLMobject` to fit a height while keeping width/depth proportional."""return self.rescale_to_fit(height, 1, stretch=stretch, **kwargs)scale_to_fit_height = set_height- def set_depth(self, depth, stretch=False, **kwargs):+ def set_depth(self, depth: float, stretch: bool = False, **kwargs):"""Scales the :class:`~.OpenGLMobject` to fit a depth while keeping width/height proportional."""return self.rescale_to_fit(depth, 2, stretch=stretch, **kwargs)scale_to_fit_depth = set_depth- def set_coord(self, value, dim, direction=ORIGIN):+ def set_coord(self, value: float, dim: int, direction: Vector3D = ORIGIN) -> Self:curr = self.get_coord(dim, direction)shift_vect = np.zeros(self.dim)shift_vect[dim] = value - currself.shift(shift_vect)return self- def set_x(self, x, direction=ORIGIN):+ def set_x(self, x: float, direction: Vector3D = ORIGIN) -> Self:"""Set x value of the center of the :class:`~.OpenGLMobject` (``int`` or ``float``)"""return self.set_coord(x, 0, direction)- def set_y(self, y, direction=ORIGIN):+ def set_y(self, y: float, direction: Vector3D = ORIGIN) -> Self:"""Set y value of the center of the :class:`~.OpenGLMobject` (``int`` or ``float``)"""return self.set_coord(y, 1, direction)- def set_z(self, z, direction=ORIGIN):+ def set_z(self, z: float, direction: Vector3D = ORIGIN) -> Self:"""Set z value of the center of the :class:`~.OpenGLMobject` (``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)@@ -1902,10 +1986,10 @@ class OpenGLMobject:def move_to(self,- point_or_mobject,- aligned_edge=ORIGIN,- coor_mask=np.array([1, 1, 1]),- ):+ point_or_mobject: Point3D | OpenGLMobject,+ aligned_edge: Vector3D = ORIGIN,+ coor_mask: Point3D = np.array([1, 1, 1]),+ ) -> Self:"""Move center of the :class:`~.OpenGLMobject` to certain coordinate."""if isinstance(point_or_mobject, OpenGLMobject):target = point_or_mobject.get_bounding_box_point(aligned_edge)@@ -1915,7 +1999,12 @@ class OpenGLMobject:self.shift((target - point_to_align) * coor_mask)return self- def replace(self, mobject, dim_to_match=0, stretch=False):+ def replace(+ self,+ mobject: OpenGLMobject,+ dim_to_match: int = 0,+ stretch: bool = False,+ ) -> Self:if not mobject.get_num_points() and not mobject.submobjects:self.scale(0)return self@@ -1937,13 +2026,13 @@ class OpenGLMobject: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_startif np.all(curr_vect == 0):@@ -1968,7 +2057,13 @@ class OpenGLMobject:# Color functions- def set_rgba_array(self, color=None, opacity=None, name="rgbas", recurse=True):+ def set_rgba_array(+ self,+ color: ParsableManimColor | Iterable[ParsableManimColor] | None = None,+ opacity: float | Iterable[float] | None = None,+ name: str = "rgbas",+ recurse: bool = True,+ ) -> Self:if color is not None:rgbs = np.array([color_to_rgb(c) for c in listify(color)])if opacity is not None:@@ -1998,7 +2093,12 @@ class OpenGLMobject:mob.data[name] = rgbas.copy()return self- def set_rgba_array_direct(self, rgbas: np.ndarray, name="rgbas", recurse=True):+ def set_rgba_array_direct(+ self,+ rgbas: npt.NDArray[RGBA_Array_Float],+ name: str = "rgbas",+ recurse: bool = True,+ ) -> Self:"""Directly set rgba data from `rgbas` and optionally do the same recursivelywith submobjects. This can be used if the `rgbas` have already been generatedwith the correct shape and simply need to be set.@@ -2015,7 +2115,12 @@ class OpenGLMobject:for mob in self.get_family(recurse):mob.data[name] = rgbas.copy()- def set_color(self, color: ParsableManimColor | None, opacity=None, recurse=True):+ def set_color(+ self,+ color: ParsableManimColor | Iterable[ParsableManimColor] | None,+ opacity: float | Iterable[float] | None = None,+ recurse: bool = True,+ ) -> Self:self.set_rgba_array(color, opacity, recurse=False)# Recurse to submobjects differently from how set_rgba_array# in case they implement set_color differently@@ -2028,24 +2133,25 @@ class OpenGLMobject:submob.set_color(color, recurse=True)return self- def set_opacity(self, opacity, recurse=True):+ def set_opacity(+ self, opacity: float | Iterable[float] | None, recurse: bool = True+ ) -> Self:self.set_rgba_array(color=None, opacity=opacity, recurse=False)if recurse:for submob in self.submobjects:submob.set_opacity(opacity, recurse=True)return self- def get_color(self):+ def get_color(self) -> str:return rgb_to_hex(self.rgbas[0, :3])- def get_opacity(self):+ def get_opacity(self) -> float:return self.rgbas[0, 3]- def set_color_by_gradient(self, *colors):- self.set_submobject_colors_by_gradient(*colors)- return self+ def set_color_by_gradient(self, *colors: ParsableManimColor) -> Self:+ return self.set_submobject_colors_by_gradient(*colors)- def set_submobject_colors_by_gradient(self, *colors):+ def set_submobject_colors_by_gradient(self, *colors: ParsableManimColor) -> Self:if len(colors) == 0:raise Exception("Need at least one color")elif len(colors) == 1:@@ -2059,21 +2165,21 @@ class OpenGLMobject:mob.set_color(color)return self- def fade(self, darkness=0.5, recurse=True):- self.set_opacity(1.0 - darkness, recurse=recurse)+ def fade(self, darkness: float = 0.5, recurse: bool = True) -> Self:+ return self.set_opacity(1.0 - darkness, recurse=recurse)- def get_gloss(self):+ def get_gloss(self) -> float:return self.gloss- def set_gloss(self, gloss, recurse=True):+ def set_gloss(self, gloss: float, recurse: bool = True) -> Self:for mob in self.get_family(recurse):mob.gloss = glossreturn self- def get_shadow(self):+ def get_shadow(self) -> float:return self.shadow- def set_shadow(self, shadow, recurse=True):+ def set_shadow(self, shadow: float, recurse: bool = True) -> Self:for mob in self.get_family(recurse):mob.shadow = shadowreturn self@@ -2081,8 +2187,11 @@ class OpenGLMobject:# Background rectangledef add_background_rectangle(- self, color: ParsableManimColor | None = None, opacity: float = 0.75, **kwargs- ):+ self,+ color: ParsableManimColor | None = None,+ opacity: float = 0.75,+ **kwargs,+ ) -> Self:# TODO, this does not behave well when the mobject has points,# since it gets displayed on top"""Add a BackgroundRectangle as submobject.@@ -2120,39 +2229,39 @@ class OpenGLMobject: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# Getters- def get_bounding_box_point(self, direction):+ def get_bounding_box_point(self, direction: Vector3D) -> Point3D:bb = self.get_bounding_box()indices = (np.sign(direction) + 1).astype(int)return np.array([bb[indices[i]][i] for i in range(3)])- def get_edge_center(self, direction) -> np.ndarray:+ def get_edge_center(self, direction: Vector3D) -> Point3D:"""Get edge coordinates for certain direction."""return self.get_bounding_box_point(direction)- def get_corner(self, direction) -> np.ndarray:+ def get_corner(self, direction: Vector3D) -> Point3D:"""Get corner coordinates for certain direction."""return self.get_bounding_box_point(direction)- def get_center(self) -> np.ndarray:+ def get_center(self) -> Point3D:"""Get center coordinates."""return self.get_bounding_box()[1]- def get_center_of_mass(self):+ def get_center_of_mass(self) -> Point3D:return self.get_all_points().mean(0)- def get_boundary_point(self, direction):+ def get_boundary_point(self, direction: Vector3D) -> Point3D:all_points = self.get_all_points()boundary_directions = all_points - self.get_center()norms = np.linalg.norm(boundary_directions, axis=1)@@ -2160,7 +2269,7 @@ class OpenGLMobject:index = np.argmax(np.dot(boundary_directions, np.array(direction).T))return all_points[index]- def get_continuous_bounding_box_point(self, direction):+ def get_continuous_bounding_box_point(self, direction: Vector3D) -> Point3D:dl, center, ur = self.get_bounding_box()corner_vect = ur - centerreturn center + direction / np.max(@@ -2174,86 +2283,86 @@ class OpenGLMobject:),)- def get_top(self) -> np.ndarray:+ def get_top(self) -> Point3D:"""Get top coordinates of a box bounding the :class:`~.OpenGLMobject`"""return self.get_edge_center(UP)- def get_bottom(self) -> np.ndarray:+ def get_bottom(self) -> Point3D:"""Get bottom coordinates of a box bounding the :class:`~.OpenGLMobject`"""return self.get_edge_center(DOWN)- def get_right(self) -> np.ndarray:+ def get_right(self) -> Point3D:"""Get right coordinates of a box bounding the :class:`~.OpenGLMobject`"""return self.get_edge_center(RIGHT)- def get_left(self) -> np.ndarray:+ def get_left(self) -> Point3D:"""Get left coordinates of a box bounding the :class:`~.OpenGLMobject`"""return self.get_edge_center(LEFT)- def get_zenith(self) -> np.ndarray:+ def get_zenith(self) -> Point3D:"""Get zenith coordinates of a box bounding a 3D :class:`~.OpenGLMobject`."""return self.get_edge_center(OUT)- def get_nadir(self) -> np.ndarray:+ def get_nadir(self) -> Point3D:"""Get nadir (opposite the zenith) coordinates of a box bounding a 3D :class:`~.OpenGLMobject`."""return self.get_edge_center(IN)- def length_over_dim(self, dim):+ def length_over_dim(self, dim: int) -> float:bb = self.get_bounding_box()return abs((bb[2] - bb[0])[dim])- def get_width(self):+ def get_width(self) -> float:"""Returns the width of the mobject."""return self.length_over_dim(0)- def get_height(self):+ def get_height(self) -> float:"""Returns the height of the mobject."""return self.length_over_dim(1)- def get_depth(self):+ def get_depth(self) -> float:"""Returns the depth of the mobject."""return self.length_over_dim(2)- def get_coord(self, dim: int, direction=ORIGIN):+ def get_coord(self, dim: int, direction: Vector3D = ORIGIN) -> ManimFloat:"""Meant to generalize ``get_x``, ``get_y`` and ``get_z``"""return self.get_bounding_box_point(direction)[dim]- def get_x(self, direction=ORIGIN) -> np.float64:+ def get_x(self, direction: Vector3D = ORIGIN) -> ManimFloat:"""Returns x coordinate of the center of the :class:`~.OpenGLMobject` as ``float``"""return self.get_coord(0, direction)- def get_y(self, direction=ORIGIN) -> np.float64:+ def get_y(self, direction: Vector3D = ORIGIN) -> ManimFloat:"""Returns y coordinate of the center of the :class:`~.OpenGLMobject` as ``float``"""return self.get_coord(1, direction)- def get_z(self, direction=ORIGIN) -> np.float64:+ def get_z(self, direction: Vector3D = ORIGIN) -> ManimFloat:"""Returns z coordinate of the center of the :class:`~.OpenGLMobject` 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:`~.OpenGLMobject` 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:`~.OpenGLMobject` 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:points = self.pointsi, subalpha = integer_interpolate(0, len(points) - 1, alpha)return interpolate(points[i], points[i + 1], subalpha)- def pfp(self, alpha):+ def pfp(self, alpha: float) -> Point3D:"""Abbreviation for point_from_proportion"""return self.point_from_proportion(alpha)- def get_pieces(self, n_pieces):+ def get_pieces(self, n_pieces: int) -> OpenGLMobject:template = self.copy()template.submobjects = []alphas = np.linspace(0, 1, n_pieces + 1)@@ -2264,34 +2373,36 @@ class OpenGLMobject:))- 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()# Match other mobject properties- def match_color(self, mobject: OpenGLMobject):+ def match_color(self, mobject: OpenGLMobject) -> Self:"""Match the color with the color of another :class:`~.OpenGLMobject`."""return self.set_color(mobject.get_color())- def match_dim_size(self, mobject: OpenGLMobject, dim, **kwargs):+ def match_dim_size(self, mobject: OpenGLMobject, dim: int, **kwargs) -> Self:"""Match the specified dimension with the dimension of another :class:`~.OpenGLMobject`."""return self.rescale_to_fit(mobject.length_over_dim(dim), dim, **kwargs)- def match_width(self, mobject: OpenGLMobject, **kwargs):+ def match_width(self, mobject: OpenGLMobject, **kwargs) -> Self:"""Match the width with the width of another :class:`~.OpenGLMobject`."""return self.match_dim_size(mobject, 0, **kwargs)- def match_height(self, mobject: OpenGLMobject, **kwargs):+ def match_height(self, mobject: OpenGLMobject, **kwargs) -> Self:"""Match the height with the height of another :class:`~.OpenGLMobject`."""return self.match_dim_size(mobject, 1, **kwargs)- def match_depth(self, mobject: OpenGLMobject, **kwargs):+ def match_depth(self, mobject: OpenGLMobject, **kwargs) -> Self:"""Match the depth with the depth of another :class:`~.OpenGLMobject`."""return self.match_dim_size(mobject, 2, **kwargs)- def match_coord(self, mobject: OpenGLMobject, dim, direction=ORIGIN):+ def match_coord(+ self, mobject: OpenGLMobject, dim: int, direction: Vector3D = ORIGIN+ ) -> Self:"""Match the coordinates with the coordinates of another :class:`~.OpenGLMobject`."""return self.set_coord(mobject.get_coord(dim, direction),@@ -2299,23 +2410,23 @@ class OpenGLMobject:direction=direction,)- def match_x(self, mobject, direction=ORIGIN):+ def match_x(self, mobject: OpenGLMobject, direction: Vector3D = ORIGIN) -> Self:"""Match x coord. to the x coord. of another :class:`~.OpenGLMobject`."""return self.match_coord(mobject, 0, direction)- def match_y(self, mobject, direction=ORIGIN):+ def match_y(self, mobject: OpenGLMobject, direction: Vector3D = ORIGIN) -> Self:"""Match y coord. to the x coord. of another :class:`~.OpenGLMobject`."""return self.match_coord(mobject, 1, direction)- def match_z(self, mobject, direction=ORIGIN):+ def match_z(self, mobject: OpenGLMobject, direction: Vector3D = ORIGIN) -> Self:"""Match z coord. to the x coord. of another :class:`~.OpenGLMobject`."""return self.match_coord(mobject, 2, direction)def align_to(self,- mobject_or_point: OpenGLMobject | Sequence[float],- direction=ORIGIN,- ):+ mobject_or_point: OpenGLMobject | Point3D,+ direction: Vector3D = ORIGIN,+ ) -> Self:"""Examples:mob1.align_to(mob2, UP) moves mob1 vertically so that its@@ -2335,21 +2446,22 @@ class OpenGLMobject:self.set_coord(point[dim], dim, direction)return self- def get_group_class(self):+ def get_group_class(self) -> type[OpenGLGroup]:return OpenGLGroup@staticmethod- def get_mobject_type_class():+ def get_mobject_type_class() -> type[OpenGLMobject]:"""Return the base class of this mobject type."""return OpenGLMobject# Alignment- def align_data_and_family(self, mobject):+ def align_data_and_family(self, mobject: OpenGLMobject) -> Self:self.align_family(mobject)self.align_data(mobject)+ return self- def align_data(self, mobject):+ def align_data(self, mobject: OpenGLMobject) -> Self:# In case any data arrays get resized when aligned to shader data# self.refresh_shader_data()for mob1, mob2 in zip(self.get_family(), mobject.get_family()):@@ -2365,14 +2477,15 @@ class OpenGLMobject:mob1.data[key] = resize_preserving_order(arr1, len(arr2))elif len(arr1) > len(arr2):mob2.data[key] = resize_preserving_order(arr2, len(arr1))+ return self- def align_points(self, mobject):+ def align_points(self, mobject: OpenGLMobject) -> Self:max_len = max(self.get_num_points(), mobject.get_num_points())for mob in (self, mobject):mob.resize_points(max_len, resize_func=resize_preserving_order)return self- def align_family(self, mobject):+ def align_family(self, mobject: OpenGLMobject) -> Self:mob1 = selfmob2 = mobjectn1 = len(mob1)@@ -2385,14 +2498,14 @@ class OpenGLMobject:sm1.align_family(sm2)return self- def push_self_into_submobjects(self):+ def push_self_into_submobjects(self) -> Self:copy = self.deepcopy()copy.submobjects = []self.resize_points(0)self.add(copy)return self- def add_n_more_submobjects(self, n):+ def add_n_more_submobjects(self, n: int) -> Self:if n == 0:return self@@ -2421,7 +2534,13 @@ class OpenGLMobject:# Interpolate- def interpolate(self, mobject1, mobject2, alpha, path_func=straight_path()):+ def interpolate(+ self,+ mobject1: OpenGLMobject,+ mobject2: OpenGLMobject,+ alpha: float,+ path_func: PathFuncType = straight_path(),+ ) -> Self:"""Turns this :class:`~.OpenGLMobject` into an interpolation between ``mobject1``and ``mobject2``.@@ -2474,7 +2593,9 @@ class OpenGLMobject:)return self- def pointwise_become_partial(self, mobject, a, b):+ def pointwise_become_partial(+ self, mobject: OpenGLMobject, a: float, b: float+ ) -> None:"""Set points in such a way as to become onlypart of mobject.@@ -2491,7 +2612,7 @@ class OpenGLMobject:match_depth: bool = False,match_center: bool = False,stretch: bool = False,- ):+ ) -> Self:"""Edit all data and submobjects to be identicalto another :class:`~.OpenGLMobject`@@ -2551,7 +2672,7 @@ class OpenGLMobject:# Locking data- def lock_data(self, keys):+ def lock_data(self, keys: Iterable[str]) -> None:"""To speed up some animations, particularly transformations,it can be handy to acknowledge which pieces of data@@ -2565,7 +2686,9 @@ class OpenGLMobject:self.refresh_shader_data()self.locked_data_keys = set(keys)- def lock_matching_data(self, mobject1, mobject2):+ def lock_matching_data(+ self, mobject1: OpenGLMobject, mobject2: OpenGLMobject+ ) -> Self:for sm, sm1, sm2 in zip(self.get_family(),mobject1.get_family(),@@ -2582,57 +2705,57 @@ class OpenGLMobject:)return self- def unlock_data(self):+ def unlock_data(self) -> None:for mob in self.get_family():mob.locked_data_keys = set()# Operations touching shader uniforms@affects_shader_info_id- def fix_in_frame(self):+ def fix_in_frame(self) -> Self:self.is_fixed_in_frame = 1.0return self@affects_shader_info_id- def fix_orientation(self):+ def fix_orientation(self) -> Self:self.is_fixed_orientation = 1.0self.fixed_orientation_center = tuple(self.get_center())self.depth_test = Truereturn self@affects_shader_info_id- def unfix_from_frame(self):+ def unfix_from_frame(self) -> Self:self.is_fixed_in_frame = 0.0return self@affects_shader_info_id- def unfix_orientation(self):+ def unfix_orientation(self) -> Self:self.is_fixed_orientation = 0.0self.fixed_orientation_center = (0, 0, 0)self.depth_test = Falsereturn self@affects_shader_info_id- def apply_depth_test(self):+ def apply_depth_test(self) -> Self:self.depth_test = Truereturn self@affects_shader_info_id- def deactivate_depth_test(self):+ def deactivate_depth_test(self) -> Self:self.depth_test = Falsereturn self# Shader code manipulation- def replace_shader_code(self, old, new):+ def replace_shader_code(self, old_code: str, new_code: str) -> Self:# TODO, will this work with VMobject structure, given# that it does not simpler return shader_wrappers of# family?for wrapper in self.get_shader_wrapper_list():- wrapper.replace_code(old, new)+ wrapper.replace_code(old_code, new_code)return self- def set_color_by_code(self, glsl_code):+ def set_color_by_code(self, glsl_code: str) -> Self:"""Takes a snippet of code and inserts it into acontext which has the following variables:@@ -2644,11 +2767,11 @@ class OpenGLMobject:def set_color_by_xyz_func(self,- glsl_snippet,- min_value=-5.0,- max_value=5.0,- colormap="viridis",- ):+ glsl_snippet: str,+ min_value: float = -5.0,+ max_value: float = 5.0,+ colormap: str = "viridis",+ ) -> Self:"""Pass in a glsl expression in terms of x, y and z which returnsa float.@@ -2665,11 +2788,11 @@ class OpenGLMobject:# For shader data- def refresh_shader_wrapper_id(self):+ def refresh_shader_wrapper_id(self) -> Self:self.get_shader_wrapper().refresh_id()return self- def get_shader_wrapper(self):+ def get_shader_wrapper(self) -> ShaderWrapper:from manim.renderer.shader_wrapper import ShaderWrapper# if hasattr(self, "__shader_wrapper"):@@ -2686,7 +2809,7 @@ class OpenGLMobject:)return self.shader_wrapper- def get_shader_wrapper_list(self):+ def get_shader_wrapper_list(self) -> Sequence[ShaderWrapper]:shader_wrappers = it.chain([self.get_shader_wrapper()],*(sm.get_shader_wrapper_list() for sm in self.submobjects),@@ -2703,7 +2826,7 @@ class OpenGLMobject:result.append(shader_wrapper)return result- def check_data_alignment(self, array, data_key):+ def check_data_alignment(self, array: npt.NDArray, data_key: str) -> Self:# Makes sure that self.data[key] can be broadcast into# the given array, meaning its length has to be either 1# or the length of the array@@ -2715,45 +2838,50 @@ class OpenGLMobject:)return self- def get_resized_shader_data_array(self, length):+ def get_resized_shader_data_array(self, length: float) -> npt.NDArray:# If possible, try to populate an existing array, rather# than recreating it each framepoints = self.pointsshader_data = np.zeros(len(points), dtype=self.shader_dtype)return shader_data- def read_data_to_shader(self, shader_data, shader_data_key, data_key):+ def read_data_to_shader(+ self,+ shader_data: npt.NDArray, # has structured data type, ex. ("point", np.float32, (3,))+ shader_data_key: str,+ data_key: str,+ ) -> None:if data_key in self.locked_data_keys:returnself.check_data_alignment(shader_data, data_key)shader_data[shader_data_key] = self.data[data_key]- def get_shader_data(self):+ def get_shader_data(self) -> npt.NDArray:shader_data = self.get_resized_shader_data_array(self.get_num_points())self.read_data_to_shader(shader_data, "point", "points")return shader_data- def refresh_shader_data(self):+ def refresh_shader_data(self) -> None:self.get_shader_data()- def get_shader_uniforms(self):+ def get_shader_uniforms(self) -> dict[str, Any]:return self.uniforms- def get_shader_vert_indices(self):+ def get_shader_vert_indices(self) -> Sequence[int]:return self.shader_indices@property- def submobjects(self):+ def submobjects(self) -> Sequence[OpenGLMobject]:return self._submobjects if hasattr(self, "_submobjects") else []@submobjects.setter- def submobjects(self, submobject_list):+ def submobjects(self, submobject_list: Iterable[OpenGLMobject]) -> None:self.remove(*self.submobjects)self.add(*submobject_list)# Errors- def throw_error_if_no_points(self):+ def throw_error_if_no_points(self) -> None:if not self.has_points():message = ("Cannot call OpenGLMobject.{} " + "for a OpenGLMobject with no points"@@ -2763,38 +2891,42 @@ class OpenGLMobject:class OpenGLGroup(OpenGLMobject):- def __init__(self, *mobjects, **kwargs):+ def __init__(self, *mobjects: OpenGLMobject, **kwargs):super().__init__(**kwargs)self.add(*mobjects)class OpenGLPoint(OpenGLMobject):def __init__(- self, location=ORIGIN, artificial_width=1e-6, artificial_height=1e-6, **kwargs+ self,+ location: Point3D = ORIGIN,+ artificial_width: float = 1e-6,+ artificial_height: float = 1e-6,+ **kwargs,):self.artificial_width = artificial_widthself.artificial_height = artificial_heightsuper().__init__(**kwargs)self.set_location(location)- def get_width(self):+ def get_width(self) -> float:return self.artificial_width- def get_height(self):+ def get_height(self) -> float:return self.artificial_height- def get_location(self):+ def get_location(self) -> Point3D:return self.points[0].copy()- def get_bounding_box_point(self, *args, **kwargs):+ def get_bounding_box_point(self, *args, **kwargs) -> Point3D:return self.get_location()- def set_location(self, new_loc):+ def set_location(self, new_loc: Point3D) -> None:self.set_points(np.array(new_loc, ndmin=2, dtype=float))class _AnimationBuilder:- def __init__(self, mobject):+ def __init__(self, mobject: OpenGLMobject):self.mobject = mobjectself.mobject.generate_target()@@ -2806,7 +2938,7 @@ class _AnimationBuilder:self.cannot_pass_args = Falseself.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",@@ -2817,7 +2949,7 @@ class _AnimationBuilder:return self- def __getattr__(self, method_name):+ def __getattr__(self, method_name: str) -> Callable[..., Self]:method = getattr(self.mobject.target, method_name)has_overridden_animation = hasattr(method, "_override_animate")@@ -2845,7 +2977,7 @@ class _AnimationBuilder:return update_target- def build(self):+ def build(self) -> _MethodAnimation:from manim.animation.transform import _MethodAnimationif self.overridden_animation:@@ -2859,7 +2991,7 @@ class _AnimationBuilder:return anim-def override_animate(method):+def override_animate(method: types.FunctionType) -> types.FunctionType:r"""Decorator for overriding method animations.This allows to specify a method (returning an :class:`~.Animation`)