A community-maintained Python framework for creating mathematical animations.
Add type annotations to `opengl_mobject.py` (#4398)
Riccardo Bergamaschi855ea863b690
diff --git a/manim/mobject/opengl/opengl_mobject.py b/manim/mobject/opengl/opengl_mobject.pyindex 5fd7def78..206a114cc 100644--- a/manim/mobject/opengl/opengl_mobject.py+++ b/manim/mobject/opengl/opengl_mobject.py@@ -9,15 +9,29 @@ import typesfrom collections.abc import Callable, Iterable, Iterator, Sequencefrom functools import partialmethod, wrapsfrom math import ceil-from typing import TYPE_CHECKING, Any, TypeVar+from typing import TYPE_CHECKING, Any, ClassVar, Protocol, TypeVar, castimport modernglimport numpy as np+import numpy.typing as npt+from typing_extensions import (+ Never,+ Self,+ TypeAlias,+ overload,+ override,+)from manim import config, loggerfrom manim.constants import *from manim.data_structures import MethodWithArgsfrom manim.renderer.shader_wrapper import get_colormap_code+from manim.typing import (+ Point3D,+ Point3D_Array,+ Point3DLike,+ Point3DLike_Array,+)from manim.utils.bezier import integer_interpolate, interpolatefrom manim.utils.color import (WHITE,@@ -48,9 +62,7 @@ from manim.utils.space_ops import ()if TYPE_CHECKING:- import numpy.typing as npt- from typing_extensions import Self, TypeAlias-+ from manim.animation.animation import Animationfrom manim.renderer.shader_wrapper import ShaderWrapperfrom manim.typing import (FloatRGB_Array,@@ -60,19 +72,16 @@ if TYPE_CHECKING:MatrixMN,MultiMappingFunction,PathFuncType,- Point3D,- Point3D_Array,- Point3DLike,- Point3DLike_Array,Vector3D,Vector3DLike,)- TimeBasedUpdater: TypeAlias = Callable[["Mobject", float], object]- NonTimeBasedUpdater: TypeAlias = Callable[["Mobject"], object]- Updater: TypeAlias = NonTimeBasedUpdater | TimeBasedUpdater+ _TimeBasedUpdater: TypeAlias = Callable[["OpenGLMobject", float], object]+ _NonTimeBasedUpdater: TypeAlias = Callable[["OpenGLMobject"], object]+ _Updater: TypeAlias = _NonTimeBasedUpdater | _TimeBasedUpdater- T = TypeVar("T")+ _T = TypeVar("_T")+ _T_np = TypeVar("_T_np", bound=np.generic)def affects_shader_info_id(@@ -91,6 +100,11 @@ def affects_shader_info_id(__all__ = ["OpenGLMobject", "OpenGLGroup", "OpenGLPoint", "_AnimationBuilder"]+_ShaderDType: TypeAlias = np.void+"""The dtype for NumPy arrays representing shader data. It's a structured dtype with signature `(point, np.float32, (3,))`."""+_ShaderData: TypeAlias = npt.NDArray[_ShaderDType]++class OpenGLMobject:"""Mathematical Object: base class for objects that can be displayed on screen.@@ -107,25 +121,29 @@ class OpenGLMobject:"""- shader_dtype = [+ _original__init__: ClassVar[Callable[..., None]]++ shader_dtype: ClassVar[Sequence[tuple[str, type[np.generic], tuple[int, ...]]]] = [("point", np.float32, (3,)),]- shader_folder = ""+ shader_folder: ClassVar[str] = ""# _Data and _Uniforms are set as class variables to tell manim how to handle setting/getting these attributes later.- points = _Data()- bounding_box = _Data()- rgbas = _Data()-- is_fixed_in_frame = _Uniforms()- is_fixed_orientation = _Uniforms()- fixed_orientation_center = _Uniforms() # for fixed orientation reference- gloss = _Uniforms()- shadow = _Uniforms()+ points: _Data[Point3D_Array] = _Data()+ bounding_box: _Data[Point3D_Array] = _Data()+ rgbas: _Data[FloatRGBA_Array] = _Data()++ is_fixed_in_frame: _Uniforms = _Uniforms()+ is_fixed_orientation: _Uniforms = _Uniforms()+ fixed_orientation_center: _Uniforms[tuple[float, float, float]] = (+ _Uniforms()+ ) # for fixed orientation reference+ gloss: _Uniforms = _Uniforms()+ shadow: _Uniforms = _Uniforms()def __init__(self,- color: ParsableManimColor | Iterable[ParsableManimColor] = WHITE,+ color: ParsableManimColor | Sequence[ParsableManimColor] = WHITE,opacity: float = 1,dim: int = 3, # TODO, get rid of this# Lighting parameters@@ -146,40 +164,42 @@ class OpenGLMobject:model_matrix: MatrixMN | None = None,should_render: bool = True,name: str | None = None,- **kwargs,+ **kwargs: Any,):- self.name = self.__class__.__name__ if name is None else name+ self.name: str = self.__class__.__name__ if name is None else name# getattr in case data/uniforms are already defined in parent classes.- self.data = getattr(self, "data", {})- self.uniforms = getattr(self, "uniforms", {})+ self.data: dict[str, npt.NDArray[Any]] = getattr(self, "data", {})+ self.uniforms: dict[str, float | tuple[float, ...]] = getattr(+ self, "uniforms", {}+ )- self.opacity = opacity- self.dim = dim # TODO, get rid of this+ self.opacity: float | Iterable[float] = opacity+ self.dim: int = dim # TODO, get rid of this# Lighting parameters# Positive gloss up to 1 makes it reflect the light.self.gloss = gloss# Positive shadow up to 1 makes a side opposite the light darkerself.shadow = shadow# For shaders- self.render_primitive = render_primitive- self.texture_paths = texture_paths- self.depth_test = depth_test+ self.render_primitive: int = render_primitive+ self.texture_paths: dict[str, str] | None = texture_paths+ self.depth_test: bool = depth_test# If true, the mobject will not get rotated according to camera positionself.is_fixed_in_frame = float(is_fixed_in_frame)self.is_fixed_orientation = float(is_fixed_orientation)self.fixed_orientation_center = (0, 0, 0)# Must match in attributes of vert shader# Event listener- self.listen_to_events = listen_to_events-- self._submobjects = []- self.parents = []- self.parent = None- self.family = [self]- self.locked_data_keys = set()- self.needs_new_bounding_box = True+ self.listen_to_events: bool = listen_to_events++ self._submobjects: list[OpenGLMobject] = []+ self.parents: list[OpenGLMobject] = []+ self.parent: OpenGLMobject | None = None+ self.family: list[OpenGLMobject] = [self]+ self.locked_data_keys: set[str] = set()+ self.needs_new_bounding_box: bool = Trueif model_matrix is None:- self.model_matrix = np.eye(4)+ self.model_matrix: MatrixMN = np.eye(4)else:self.model_matrix = model_matrix@@ -187,15 +207,15 @@ class OpenGLMobject:self.init_updaters()# self.init_event_listners()self.init_points()- self.color = ManimColor.parse(color)+ self.color: ManimColor | list[ManimColor] = ManimColor.parse(color)self.init_colors()- self.shader_indices = None+ self.shader_indices: Sequence[int] | None = Noneif self.depth_test:self.apply_depth_test()- self.should_render = should_render+ self.should_render: bool = should_renderdef _assert_valid_submobjects(self, submobjects: Iterable[OpenGLMobject]) -> Self:"""Check that all submobjects are actually instances of@@ -256,30 +276,32 @@ class OpenGLMobject:return self@classmethod- def __init_subclass__(cls, **kwargs) -> None:+ def __init_subclass__(cls, **kwargs: Any) -> None:super().__init_subclass__(**kwargs)cls._original__init__ = cls.__init__+ @overridedef __str__(self) -> str:return self.__class__.__name__+ @overridedef __repr__(self) -> str:return str(self.name)- def __sub__(self, other):+ def __sub__(self, other: Never) -> object:return NotImplemented- def __isub__(self, other):+ def __isub__(self, other: Never) -> object:return NotImplemented- def __add__(self, mobject):+ def __add__(self, mobject: Never) -> object:return NotImplemented- def __iadd__(self, mobject):+ def __iadd__(self, mobject: Never) -> object:return NotImplemented@classmethod- def set_default(cls, **kwargs) -> None:+ def set_default(cls, **kwargs: Any) -> None:"""Sets the default values of keyword arguments.If this method is called without any additional keyword@@ -322,7 +344,9 @@ class OpenGLMobject:"""if kwargs:- cls.__init__ = partialmethod(cls.__init__, **kwargs)+ # Apparently mypy does not correctly understand `partialmethod`:+ # see https://github.com/python/mypy/issues/8619+ cls.__init__ = partialmethod(cls.__init__, **kwargs) # type: ignore[assignment]else:cls.__init__ = cls._original__init__@@ -330,18 +354,18 @@ class OpenGLMobject:"""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: Point3D_Array = np.zeros((0, 3))- self.bounding_box: Point3D_Array = np.zeros((3, 3))- self.rgbas: FloatRGBA_Array = np.zeros((1, 4))+ self.points = np.zeros((0, 3))+ self.bounding_box = np.zeros((3, 3))+ self.rgbas = np.zeros((1, 4))- def init_colors(self) -> object:+ def init_colors(self) -> None:"""Initializes the colors.Gets called upon creation"""self.set_color(self.color, self.opacity)- def init_points(self) -> object:+ def init_points(self) -> None:"""Initializes :attr:`points` and therefore the shape.Gets called upon creation. This is an empty method that can be implemented by@@ -350,7 +374,7 @@ class OpenGLMobject:# Typically implemented in subclass, unless purposefully left blankpass- def set(self, **kwargs) -> Self:+ def set(self, **kwargs: object) -> Self:"""Sets attributes.Mainly to be used along with :attr:`animate` to@@ -576,7 +600,11 @@ class OpenGLMobject:def depth(self, value: float) -> None:self.rescale_to_fit(value, 2, stretch=False)- def resize_points(self, new_length, resize_func=resize_array):+ def resize_points(+ self,+ new_length: int,+ resize_func: Callable[[Point3D_Array, int], Point3D_Array] = resize_array,+ ) -> Self:if new_length != len(self.points):self.points = resize_func(self.points, new_length)self.refresh_bounding_box()@@ -593,13 +621,15 @@ class OpenGLMobject:return selfdef apply_over_attr_arrays(- self, func: Callable[[npt.NDArray[T]], npt.NDArray[T]]+ self, func: Callable[[npt.NDArray[_T_np]], npt.NDArray[_T_np]]) -> 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 get_array_attrs(self) -> Iterable[str]:+ return ["points"]+def append_points(self, new_points: Point3DLike_Array) -> Self:self.points = np.vstack([self.points, new_points])self.refresh_bounding_box()@@ -646,7 +676,7 @@ class OpenGLMobject:about_point = self.get_bounding_box_point(about_edge)for mob in self.get_family():- arrs = []+ arrs: list[Point3D_Array] = []if mob.has_points():arrs.append(mob.points)if works_on_bounding_box:@@ -703,13 +733,13 @@ class OpenGLMobject:def has_points(self) -> bool:return self.get_num_points() > 0- def get_bounding_box(self) -> npt.NDArray[float]:+ def get_bounding_box(self) -> Point3D_Array: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) -> npt.NDArray[float]:+ def compute_bounding_box(self) -> Point3D_Array:all_points = np.vstack([self.points,@@ -745,7 +775,8 @@ class OpenGLMobject:bb = self.get_bounding_box()mins = bb[0] - buffmaxs = bb[2] + buff- return (point >= mins).all() and (point <= maxs).all()+ rv: bool = (point >= mins).all() and (point <= maxs).all()+ return rv# Family matters@@ -995,7 +1026,10 @@ class OpenGLMobject:# Submobject organizationdef arrange(- self, direction: Vector3DLike = RIGHT, center: bool = True, **kwargs+ self,+ direction: Vector3DLike = RIGHT,+ center: bool = True,+ **kwargs: Any,) -> Self:"""Sorts :class:`~.OpenGLMobject` next to each other on screen.@@ -1031,7 +1065,7 @@ class OpenGLMobject:row_heights: Sequence[float | None] | None = None,col_widths: Sequence[float | None] | None = None,flow_order: str = "rd",- **kwargs,+ **kwargs: Any,) -> Self:"""Arrange submobjects in a grid.@@ -1181,28 +1215,28 @@ class OpenGLMobject:) -> Sequence[Vector3D]:if str_alignments is None:# Use cell_alignment as fallback- return [cell_alignment * direction] * num+ return [cast(Vector3D, cell_alignment * direction)] * numif len(str_alignments) != num:raise ValueError(f"{name}_alignments has a mismatching size.")return [mapping[letter] for letter in str_alignments]- row_alignments = init_alignments(+ row_alignments_seq: Sequence[Vector3D] = init_alignments(row_alignments,rows,{"u": UP, "c": ORIGIN, "d": DOWN},"row",RIGHT,)- col_alignments = init_alignments(+ col_alignments_seq: Sequence[Vector3D] = init_alignments(col_alignments,cols,{"l": LEFT, "c": ORIGIN, "r": RIGHT},"col",UP,)- # Now row_alignment[r] + col_alignment[c] is the alignment in cell [r][c]+ # Now row_alignments_seq[r] + col_alignment_seq[c] is the alignment in cell [r][c]- mapper = {+ mapper: dict[str, Callable[[int, int], int]] = {"dr": lambda r, c: (rows - r - 1) + c * rows,"dl": lambda r, c: (rows - r - 1) + (cols - c - 1) * rows,"ur": lambda r, c: r + c * rows,@@ -1213,21 +1247,31 @@ class OpenGLMobject:"lu": lambda r, c: r * cols + (cols - c - 1),}if flow_order not in mapper:+ valid_flow_orders = ",".join([f'"{key}"' for key in mapper])raise ValueError(- 'flow_order must be one of the following values: "dr", "rd", "ld" "dl", "ru", "ur", "lu", "ul".',+ f"flow_order must be one of the following values: {valid_flow_orders}.",)- flow_order = mapper[flow_order]+ flow_order_func = mapper[flow_order]# Reverse row_alignments and row_heights. Necessary since the# grid filling is handled bottom up for simplicity reasons.- def reverse(maybe_list: Sequence[Any] | None) -> Sequence[Any] | None:+ if TYPE_CHECKING:++ @overload+ def reverse(maybe_list: None) -> None: ...+ @overload+ def reverse(maybe_list: Sequence[_T]) -> list[_T]: ...+ @overload+ def reverse(maybe_list: Sequence[_T] | None) -> list[_T] | None: ...++ def reverse(maybe_list: Sequence[_T] | None) -> list[_T] | None:if maybe_list is not None:maybe_list = list(maybe_list)maybe_list.reverse()return maybe_listreturn None- row_alignments = reverse(row_alignments)+ row_alignments_seq = reverse(row_alignments_seq)row_heights = reverse(row_heights)placeholder = OpenGLMobject()@@ -1236,7 +1280,7 @@ class OpenGLMobject:# properties of 0.mobs.extend([placeholder] * (rows * cols - len(mobs)))- grid = [[mobs[flow_order(r, c)] for c in range(cols)] for r in range(rows)]+ grid = [[mobs[flow_order_func(r, c)] for c in range(cols)] for r in range(rows)]measured_heigths = [max(grid[r][c].height for c in range(cols)) for r in range(rows)@@ -1257,18 +1301,19 @@ class OpenGLMobject:if len(sizes) != num:raise ValueError(f"{name} has a mismatching size.")return [- sizes[i] if sizes[i] is not None else measures[i] for i in range(num)+ size if (size := sizes[i]) is not None else measures[i]+ for i in range(num)]heights = init_sizes(row_heights, rows, measured_heigths, "row_heights")widths = init_sizes(col_widths, cols, measured_widths, "col_widths")- x, y = 0, 0+ x, y = 0.0, 0.0for r in range(rows):- x = 0+ x = 0.0for c in range(cols):if grid[r][c] is not placeholder:- alignment = row_alignments[r] + col_alignments[c]+ alignment = row_alignments_seq[r] + col_alignments_seq[c]line = Line(x * RIGHT + y * UP,(x + widths[c]) * RIGHT + (y + heights[r]) * UP,@@ -1285,7 +1330,11 @@ class OpenGLMobject:return selfdef get_grid(- self, n_rows: int, n_cols: int, height: float | None = None, **kwargs+ self,+ n_rows: int,+ n_cols: int,+ height: float | None = None,+ **kwargs: Any,) -> OpenGLGroup:"""Returns a new mobject containing multiple copies of this one@@ -1432,7 +1481,7 @@ class OpenGLMobject:return resultdef generate_target(self, use_deepcopy: bool = False) -> OpenGLMobject:- self.target = None # Prevent exponential explosion+ self.target: OpenGLMobject | None = None # Prevent exponential explosionif use_deepcopy:self.target = self.deepcopy()else:@@ -1443,7 +1492,7 @@ class OpenGLMobject:"""Save the current state (position, color & size). Can be restored with :meth:`~.OpenGLMobject.restore`."""if hasattr(self, "saved_state"):# Prevent exponential growth of data- self.saved_state = None+ self.saved_state: OpenGLMobject | None = Noneif use_deepcopy:self.saved_state = self.deepcopy()else:@@ -1452,7 +1501,7 @@ class OpenGLMobject: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:+ if not hasattr(self, "saved_state") or self.saved_state is None:raise Exception("Trying to restore without having saved")self.become(self.saved_state)return self@@ -1460,58 +1509,62 @@ class OpenGLMobject:# Updatingdef init_updaters(self) -> None:- self.time_based_updaters = []- self.non_time_updaters = []- self.has_updaters = False- self.updating_suspended = False+ self.time_based_updaters: list["_TimeBasedUpdater"] = [] # noqa: UP037+ self.non_time_updaters: list["_NonTimeBasedUpdater"] = [] # noqa: UP037+ self.has_updaters: bool = False+ self.updating_suspended: bool = Falsedef update(self, dt: float = 0, recurse: bool = True) -> Self:if not self.has_updaters or self.updating_suspended:return self- for updater in self.time_based_updaters:- updater(self, dt)- for updater in self.non_time_updaters:- updater(self)+ for time_based_updater in self.time_based_updaters:+ time_based_updater(self, dt)+ for non_time_updater in self.non_time_updaters:+ non_time_updater(self)if recurse:for submob in self.submobjects:submob.update(dt, recurse)return self- def get_time_based_updaters(self) -> Sequence[TimeBasedUpdater]:+ def get_time_based_updaters(self) -> Sequence[_TimeBasedUpdater]:return self.time_based_updatersdef has_time_based_updater(self) -> bool:return len(self.time_based_updaters) > 0- def get_updaters(self) -> Sequence[Updater]:- return self.time_based_updaters + self.non_time_updaters+ def get_updaters(self) -> Sequence[_Updater]:+ return cast("list[_Updater]", self.time_based_updaters) + cast(+ "list[_Updater]", self.non_time_updaters+ )- def get_family_updaters(self) -> Sequence[Updater]:+ 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: Updater,+ update_function: _Updater,index: int | None = None,call_updater: bool = False,) -> Self:+ updater_list: list[_TimeBasedUpdater] | list[_NonTimeBasedUpdater]if "dt" in inspect.signature(update_function).parameters:updater_list = self.time_based_updaterselse:updater_list = self.non_time_updatersif index is None:- updater_list.append(update_function)+ cast("list[_Updater]", updater_list).append(update_function)else:- updater_list.insert(index, update_function)+ cast("list[_Updater]", updater_list).insert(index, update_function)self.refresh_has_updater_status()if call_updater:self.update()return self- def remove_updater(self, update_function: Updater) -> Self:+ def remove_updater(self, update_function: _Updater) -> Self:for updater_list in [self.time_based_updaters, self.non_time_updaters]:+ updater_list = cast("list[_Updater]", updater_list)while update_function in updater_list:updater_list.remove(update_function)self.refresh_has_updater_status()@@ -1567,9 +1620,9 @@ class OpenGLMobject:def scale(self,scale_factor: float,- about_point: Sequence[float] | None = None,- about_edge: Sequence[float] = ORIGIN,- **kwargs,+ about_point: Point3DLike | None = None,+ about_edge: Point3DLike | None = ORIGIN,+ **_kwargs: object,) -> Self:r"""Scale the size by a factor.@@ -1622,11 +1675,10 @@ class OpenGLMobject:about_point=about_point,about_edge=about_edge,works_on_bounding_box=True,- **kwargs,)return self- def stretch(self, factor: float, dim: int, **kwargs) -> Self:+ def stretch(self, factor: float, dim: int, **kwargs: Any) -> Self:def func(points: Point3D_Array) -> Point3D_Array:points[:, dim] *= factorreturn points@@ -1642,7 +1694,7 @@ class OpenGLMobject:angle: float,axis: Vector3DLike = OUT,about_point: Point3DLike | None = None,- **kwargs,+ **kwargs: Any,) -> Self:"""Rotates the :class:`~.OpenGLMobject` about a certain point."""rot_matrix_T = rotation_matrix_transpose(angle, axis)@@ -1653,7 +1705,7 @@ class OpenGLMobject:)return self- def flip(self, axis: Vector3DLike = UP, **kwargs) -> Self:+ def flip(self, axis: Vector3DLike = UP, **kwargs: Any) -> Self:"""Flips/Mirrors an mobject about its center.Examples@@ -1672,7 +1724,7 @@ class OpenGLMobject:"""return self.rotate(TAU / 2, axis, **kwargs)- def apply_function(self, function: MappingFunction, **kwargs) -> Self:+ def apply_function(self, function: MappingFunction, **kwargs: Any) -> Self:# Default to applying matrix about the origin, not mobjects centerif len(kwargs) == 0:kwargs["about_point"] = ORIGIN@@ -1693,7 +1745,7 @@ class OpenGLMobject:submob.apply_function_to_position(function)return self- def apply_matrix(self, matrix: MatrixMN, **kwargs) -> Self:+ def apply_matrix(self, matrix: MatrixMN, **kwargs: Any) -> 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@@ -1706,7 +1758,7 @@ class OpenGLMobject:return selfdef apply_complex_function(- self, function: Callable[[complex], complex], **kwargs+ self, function: Callable[[complex], complex], **kwargs: Any) -> Self:"""Applies a complex function to a :class:`OpenGLMobject`.The x and y coordinates correspond to the real and imaginary parts respectively.@@ -1734,12 +1786,12 @@ class OpenGLMobject:self.play(t.animate.set_value(TAU), run_time=3)"""- def R3_func(point):+ def R3_func(point: Point3D) -> Point3D:x, y, z = pointxy_complex = function(complex(x, y))- return [xy_complex.real, xy_complex.imag, z]+ return np.array([xy_complex.real, xy_complex.imag, z])- return self.apply_function(R3_func)+ return self.apply_function(R3_func, **kwargs)def hierarchical_model_matrix(self) -> MatrixMN:if self.parent is None:@@ -1846,6 +1898,7 @@ class OpenGLMobject:np_direction = np.asarray(direction)np_aligned_edge = np.asarray(aligned_edge)+ target_point: Point3DLikeif isinstance(mobject_or_point, OpenGLMobject):mob = mobject_or_pointif index_of_submobject_to_align is not None:@@ -1867,15 +1920,18 @@ class OpenGLMobject:self.shift((target_point - point_to_align + buff * np_direction) * coor_mask)return self- def shift_onto_screen(self, **kwargs) -> Self:- space_lengths = [config["frame_x_radius"], config["frame_y_radius"]]+ def shift_onto_screen(self, **kwargs: Any) -> Self:+ space_lengths: list[float] = [+ config["frame_x_radius"],+ config["frame_y_radius"],+ ]for vect in UP, DOWN, LEFT, RIGHT:dim = np.argmax(np.abs(vect))- buff = kwargs.get("buff", DEFAULT_MOBJECT_TO_EDGE_BUFFER)+ buff: float = kwargs.get("buff", DEFAULT_MOBJECT_TO_EDGE_BUFFER)max_val = space_lengths[dim] - buffedge_center = self.get_edge_center(vect)if np.dot(edge_center, vect) > max_val:- self.to_edge(vect, **kwargs)+ self.to_edge(vect, buff=buff)return selfdef is_off_screen(self) -> bool:@@ -1885,13 +1941,17 @@ class OpenGLMobject:return Trueif self.get_bottom()[1] > config.frame_y_radius:return True- return self.get_top()[1] < -config.frame_y_radius+ return cast(float, self.get_top()[1]) < -config.frame_y_radiusdef stretch_about_point(self, factor: float, dim: int, point: Point3DLike) -> Self:return self.stretch(factor, dim, about_point=point)def rescale_to_fit(- self, length: float, dim: int, stretch: bool = False, **kwargs+ self,+ length: float,+ dim: int,+ stretch: bool = False,+ **kwargs: Any,) -> Self:old_length = self.length_over_dim(dim)if old_length == 0:@@ -1902,7 +1962,7 @@ class OpenGLMobject:self.scale(length / old_length, **kwargs)return self- def stretch_to_fit_width(self, width: float, **kwargs) -> Self:+ def stretch_to_fit_width(self, width: float, **kwargs: Any) -> Self:"""Stretches the :class:`~.OpenGLMobject` to fit a width, not keeping height/depth proportional.Returns@@ -1928,15 +1988,20 @@ class OpenGLMobject:"""return self.rescale_to_fit(width, 0, stretch=True, **kwargs)- def stretch_to_fit_height(self, height: float, **kwargs) -> Self:+ def stretch_to_fit_height(self, height: float, **kwargs: Any) -> 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: float, **kwargs) -> Self:+ def stretch_to_fit_depth(self, depth: float, **kwargs: Any) -> 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: float, stretch: bool = False, **kwargs) -> Self:+ def set_width(+ self,+ width: float,+ stretch: bool = False,+ **kwargs: Any,+ ) -> Self:"""Scales the :class:`~.OpenGLMobject` to fit a width while keeping height/depth proportional.Returns@@ -1964,13 +2029,23 @@ class OpenGLMobject:scale_to_fit_width = set_width- def set_height(self, height: float, stretch: bool = False, **kwargs) -> Self:+ def set_height(+ self,+ height: float,+ stretch: bool = False,+ **kwargs: Any,+ ) -> 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: float, stretch: bool = False, **kwargs):+ def set_depth(+ self,+ depth: float,+ stretch: bool = False,+ **kwargs: Any,+ ) -> Self:"""Scales the :class:`~.OpenGLMobject` to fit a depth while keeping width/height proportional."""return self.rescale_to_fit(depth, 2, stretch=stretch, **kwargs)@@ -1997,7 +2072,7 @@ class OpenGLMobject:"""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: float = 1.5, **kwargs) -> Self:+ def space_out_submobjects(self, factor: float = 1.5, **kwargs: Any) -> Self:self.scale(factor, **kwargs)for submob in self.submobjects:submob.scale(1.0 / factor)@@ -2010,6 +2085,7 @@ class OpenGLMobject:coor_mask: Vector3DLike = np.array([1, 1, 1]),) -> Self:"""Move center of the :class:`~.OpenGLMobject` to certain coordinate."""+ target: Point3DLikeif isinstance(point_or_mobject, OpenGLMobject):target = point_or_mobject.get_bounding_box_point(aligned_edge)else:@@ -2063,7 +2139,7 @@ class OpenGLMobject:else OUT)self.scale(- np.linalg.norm(target_vect) / np.linalg.norm(curr_vect),+ float(np.linalg.norm(target_vect) / np.linalg.norm(curr_vect)),about_point=curr_start,)self.rotate(@@ -2135,10 +2211,11 @@ class OpenGLMobject:"""for mob in self.get_family(recurse):mob.data[name] = rgbas.copy()+ return selfdef set_color(self,- color: ParsableManimColor | Iterable[ParsableManimColor] | None,+ color: ParsableManimColor | Sequence[ParsableManimColor] | None,opacity: float | Iterable[float] | None = None,recurse: bool = True,) -> Self:@@ -2146,7 +2223,7 @@ class OpenGLMobject:# Recurse to submobjects differently from how set_rgba_array# in case they implement set_color differentlyif color is not None:- self.color: ManimColor = ManimColor.parse(color)+ self.color = ManimColor.parse(color)if opacity is not None:self.opacity = opacityif recurse:@@ -2167,7 +2244,8 @@ class OpenGLMobject:return rgb_to_hex(self.rgbas[0, :3])def get_opacity(self) -> float:- return self.rgbas[0, 3]+ rv: float = self.rgbas[0, 3]+ return rvdef set_color_by_gradient(self, *colors: ParsableManimColor) -> Self:return self.set_submobject_colors_by_gradient(*colors)@@ -2211,7 +2289,7 @@ class OpenGLMobject:self,color: ParsableManimColor | None = None,opacity: float = 0.75,- **kwargs,+ **kwargs: Any,) -> Self:# TODO, this does not behave well when the mobject has points,# since it gets displayed on top@@ -2244,18 +2322,23 @@ class OpenGLMobject:"""from manim.mobject.geometry.shape_matchers import BackgroundRectangle- self.background_rectangle = BackgroundRectangle(- self, color=color, fill_opacity=opacity, **kwargs+ self.background_rectangle: BackgroundRectangle = BackgroundRectangle(+ self, # type: ignore[arg-type]+ color=color,+ fill_opacity=opacity,+ **kwargs,)- self.add_to_back(self.background_rectangle)+ self.add_to_back(self.background_rectangle) # type: ignore[arg-type]return self- def add_background_rectangle_to_submobjects(self, **kwargs) -> Self:+ def add_background_rectangle_to_submobjects(self, **kwargs: Any) -> Self:for submobject in self.submobjects:submobject.add_background_rectangle(**kwargs)return self- def add_background_rectangle_to_family_members_with_points(self, **kwargs) -> Self:+ def add_background_rectangle_to_family_members_with_points(+ self, **kwargs: Any+ ) -> Self:for mob in self.family_members_with_points():mob.add_background_rectangle(**kwargs)return self@@ -2291,7 +2374,7 @@ class OpenGLMobject:return all_points[index]def get_continuous_bounding_box_point(self, direction: Vector3DLike) -> Point3D:- dl, center, ur = self.get_bounding_box()+ _dl, center, ur = self.get_bounding_box()corner_vect = ur - centernp_direction = np.asarray(direction)return center + np_direction / np.max(@@ -2331,7 +2414,8 @@ class OpenGLMobject:def length_over_dim(self, dim: int) -> float:bb = self.get_bounding_box()- return abs((bb[2] - bb[0])[dim])+ rv: float = abs((bb[2] - bb[0])[dim])+ return rvdef get_width(self) -> float:"""Returns the width of the mobject."""@@ -2406,19 +2490,24 @@ class OpenGLMobject:"""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: int, **kwargs) -> Self:+ def match_dim_size(+ self,+ mobject: OpenGLMobject,+ dim: int,+ **kwargs: Any,+ ) -> 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) -> Self:+ def match_width(self, mobject: OpenGLMobject, **kwargs: Any) -> 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) -> Self:+ def match_height(self, mobject: OpenGLMobject, **kwargs: Any) -> 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) -> Self:+ def match_depth(self, mobject: OpenGLMobject, **kwargs: Any) -> Self:"""Match the depth with the depth of another :class:`~.OpenGLMobject`."""return self.match_dim_size(mobject, 2, **kwargs)@@ -2458,6 +2547,7 @@ class OpenGLMobject:horizontally so that it's center is directly above/belowthe center of mob2"""+ point: Point3DLikeif isinstance(mobject_or_point, OpenGLMobject):point = mobject_or_point.get_bounding_box_point(direction)else:@@ -2614,14 +2704,16 @@ class OpenGLMobject:def pointwise_become_partial(self, mobject: OpenGLMobject, a: float, b: float- ) -> None:+ ) -> Self:"""Set points in such a way as to become onlypart of mobject.Inputs 0 <= a < b <= 1 determine what portionof mobject to become.++ Returns `self` to allow method chaining."""- pass # To implement in subclass+ return self # To implement in subclassdef become(self,@@ -2799,7 +2891,8 @@ class OpenGLMobject:for char in "xyz":glsl_snippet = glsl_snippet.replace(char, "point." + char)# TODO: get_colormap_list does not exist- rgb_list = get_colormap_list(colormap)+ # See https://github.com/ManimCommunity/manim/issues/4176+ rgb_list = get_colormap_list(colormap) # type: ignore[name-defined]self.set_color_by_code(f"color.rgb = float_to_color({glsl_snippet}, {float(min_value)}, {float(max_value)}, {get_colormap_code(rgb_list)});",)@@ -2811,13 +2904,13 @@ class OpenGLMobject:self.get_shader_wrapper().refresh_id()return self- def get_shader_wrapper(self) -> ShaderWrapper:+ def get_shader_wrapper(self) -> "ShaderWrapper": # noqa: UP037from manim.renderer.shader_wrapper import ShaderWrapper- # if hasattr(self, "__shader_wrapper"):- # return self.__shader_wrapper+ # if hasattr(self, "shader_wrapper"):+ # return self.shader_wrapper- self.shader_wrapper = ShaderWrapper(+ self.shader_wrapper: ShaderWrapper = ShaderWrapper(vert_data=self.get_shader_data(),vert_indices=self.get_shader_vert_indices(),uniforms=self.get_shader_uniforms(),@@ -2828,14 +2921,14 @@ class OpenGLMobject:)return self.shader_wrapper- def get_shader_wrapper_list(self) -> Sequence[ShaderWrapper]:+ def get_shader_wrapper_list(self) -> Sequence["ShaderWrapper"]: # noqa: UP037shader_wrappers = it.chain([self.get_shader_wrapper()],*(sm.get_shader_wrapper_list() for sm in self.submobjects),)batches = batch_by_property(shader_wrappers, lambda sw: sw.get_id())- result = []+ result: list["ShaderWrapper"] = [] # noqa: UP037for wrapper_group, _ in batches:shader_wrapper = wrapper_group[0]if not shader_wrapper.is_valid():@@ -2845,7 +2938,7 @@ class OpenGLMobject:result.append(shader_wrapper)return result- def check_data_alignment(self, array: npt.NDArray, data_key: str) -> Self:+ def check_data_alignment(self, array: _ShaderData, 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@@ -2857,16 +2950,16 @@ class OpenGLMobject:)return self- def get_resized_shader_data_array(self, length: float) -> npt.NDArray:+ def get_resized_shader_data_array(self, length: float) -> _ShaderData:# If possible, try to populate an existing array, rather# than recreating it each framepoints = self.points- shader_data = np.zeros(len(points), dtype=self.shader_dtype)+ shader_data = cast(_ShaderData, np.zeros(len(points), dtype=self.shader_dtype))return shader_datadef read_data_to_shader(self,- shader_data: npt.NDArray, # has structured data type, ex. ("point", np.float32, (3,))+ shader_data: _ShaderData, # has structured data type, ex. ("point", np.float32, (3,))shader_data_key: str,data_key: str,) -> None:@@ -2875,7 +2968,7 @@ class OpenGLMobject:self.check_data_alignment(shader_data, data_key)shader_data[shader_data_key] = self.data[data_key]- def get_shader_data(self) -> npt.NDArray:+ def get_shader_data(self) -> _ShaderData:shader_data = self.get_resized_shader_data_array(self.get_num_points())self.read_data_to_shader(shader_data, "point", "points")return shader_data@@ -2886,11 +2979,11 @@ class OpenGLMobject:def get_shader_uniforms(self) -> dict[str, Any]:return self.uniforms- def get_shader_vert_indices(self) -> Sequence[int]:+ def get_shader_vert_indices(self) -> Sequence[int] | None:return self.shader_indices@property- def submobjects(self) -> Sequence[OpenGLMobject]:+ def submobjects(self) -> list[OpenGLMobject]:return self._submobjects if hasattr(self, "_submobjects") else []@submobjects.setter@@ -2910,7 +3003,7 @@ class OpenGLMobject:class OpenGLGroup(OpenGLMobject):- def __init__(self, *mobjects: OpenGLMobject, **kwargs):+ def __init__(self, *mobjects: OpenGLMobject, **kwargs: Any) -> None:super().__init__(**kwargs)self.add(*mobjects)@@ -2921,43 +3014,46 @@ class OpenGLPoint(OpenGLMobject):location: Point3DLike = ORIGIN,artificial_width: float = 1e-6,artificial_height: float = 1e-6,- **kwargs,- ):- self.artificial_width = artificial_width- self.artificial_height = artificial_height+ **kwargs: Any,+ ) -> None:+ self.artificial_width: float = artificial_width+ self.artificial_height: float = artificial_heightsuper().__init__(**kwargs)self.set_location(location)+ @overridedef get_width(self) -> float:return self.artificial_width+ @overridedef get_height(self) -> float:return self.artificial_heightdef get_location(self) -> Point3D:- return self.points[0].copy()+ return cast(Point3D, self.points[0]).copy()- def get_bounding_box_point(self, *args, **kwargs) -> Point3D:+ @override+ def get_bounding_box_point(self, *args: object, **kwargs: Any) -> Point3D:return self.get_location()- def set_location(self, new_loc: Point3D) -> None:+ def set_location(self, new_loc: Point3DLike) -> None:self.set_points(np.array(new_loc, ndmin=2, dtype=float))class _AnimationBuilder:- def __init__(self, mobject: OpenGLMobject):- self.mobject = mobject+ def __init__(self, mobject: OpenGLMobject) -> None:+ self.mobject: OpenGLMobject = mobjectself.mobject.generate_target()- self.overridden_animation = None- self.is_chaining = False+ self.overridden_animation: Animation | None = None+ self.is_chaining: bool = Falseself.methods: list[MethodWithArgs] = []# Whether animation args can be passed- self.cannot_pass_args = False- self.anim_args = {}+ self.cannot_pass_args: bool = False+ self.anim_args: dict[str, object] = {}- def __call__(self, **kwargs) -> Self:+ def __call__(self, **kwargs: Any) -> Self:if self.cannot_pass_args:raise ValueError("Animation arguments must be passed before accessing methods and can only be passed once",@@ -2977,9 +3073,14 @@ class _AnimationBuilder:"Method chaining is currently not supported for overridden animations",)- def update_target(*method_args, **method_kwargs):+ # NOTE: using `Self` here should not be a problem, because it's equivalent to a `TypeVar` introduced in `__getattr__`.+ # For this reason, here it's still in scope and can be used (that's why pyright does not flag this as an error).+ # However, mypy currently does not seem to understand this: hence the `type: ignore` comment.+ def update_target(*method_args: object, **method_kwargs: object) -> Self: # type: ignore[type-var, misc]if has_overridden_animation:- self.overridden_animation = method._override_animate(+ self.overridden_animation = cast(+ "Callable[..., Animation]", method._override_animate+ )(self.mobject,*method_args,anim_args=self.anim_args,@@ -2995,10 +3096,12 @@ class _AnimationBuilder:return update_target- def build(self) -> _MethodAnimation:+ def build(self) -> "Animation": # noqa: UP037from manim.animation.transform import _MethodAnimation- anim = self.overridden_animation or _MethodAnimation(self.mobject, self.methods)+ # NOTE: To fix this mypy error, we'll need to update `_MethodAnimation` to accept `Mobject | OpenGLMobject` instead of `Mobject`.+ # Once that is done, the `type: ignore` comment below won't be necessary anymore and mypy will emit a corresponding warning.+ anim = self.overridden_animation or _MethodAnimation(self.mobject, self.methods) # type: ignore[arg-type]for attr, value in self.anim_args.items():setattr(anim, attr, value)@@ -3006,7 +3109,15 @@ class _AnimationBuilder:return anim-def override_animate(method: types.FunctionType) -> types.FunctionType:+_Decorated = TypeVar("_Decorated", bound=Callable[..., "Animation"])+++class _OverrideAnimateDecorator(Protocol):+ # The slash divider on the next line prevents a mypy error in line 3176.+ def __call__(self, decorated: _Decorated, /) -> _Decorated: ...+++def override_animate(method: types.FunctionType) -> _OverrideAnimateDecorator:r"""Decorator for overriding method animations.This allows to specify a method (returning an :class:`~.Animation`)@@ -3058,8 +3169,8 @@ def override_animate(method: types.FunctionType) -> types.FunctionType:"""- def decorator(animation_method):- method._override_animate = animation_method+ def decorator(animation_method: _Decorated) -> _Decorated:+ method._override_animate = animation_method # type: ignore[attr-defined]return animation_methodreturn decoratordiff --git a/manim/renderer/shader_wrapper.py b/manim/renderer/shader_wrapper.pyindex 84975b4f5..0b3e5488d 100644--- a/manim/renderer/shader_wrapper.py+++ b/manim/renderer/shader_wrapper.py@@ -3,11 +3,14 @@ from __future__ import annotationsimport copyimport loggingimport re+from collections.abc import Mapping, Sequencefrom pathlib import Pathfrom typing import TYPE_CHECKINGimport modernglimport numpy as np+import numpy.typing as npt+from typing_extensions import Self, TypeAliasif TYPE_CHECKING:from manim.typing import FloatRGBLike_Array@@ -40,25 +43,31 @@ def find_file(file_name: Path, directories: list[Path]) -> Path:raise OSError(f"{file_name} not Found")+_ShaderDType: TypeAlias = np.void+_ShaderData: TypeAlias = npt.NDArray[_ShaderDType]++class ShaderWrapper:def __init__(self,- vert_data=None,- vert_indices=None,- shader_folder=None,- uniforms=None, # A dictionary mapping names of uniform variables- texture_paths=None, # A dictionary mapping names to filepaths for textures.- depth_test=False,- render_primitive=moderngl.TRIANGLE_STRIP,+ vert_data: _ShaderData = None,+ vert_indices: Sequence[int] | None = None,+ shader_folder: Path | str | None = None,+ # A dictionary mapping names of uniform variables+ uniforms: dict[str, float | tuple[float, ...]] | None = None,+ # A dictionary mapping names to filepaths for textures.+ texture_paths: Mapping[str, Path | str] | None = None,+ depth_test: bool = False,+ render_primitive: int | str = moderngl.TRIANGLE_STRIP,):- self.vert_data = vert_data- self.vert_indices = vert_indices- self.vert_attributes = vert_data.dtype.names- self.shader_folder = Path(shader_folder or "")- self.uniforms = uniforms or {}- self.texture_paths = texture_paths or {}- self.depth_test = depth_test- self.render_primitive = str(render_primitive)+ self.vert_data: _ShaderData = vert_data+ self.vert_indices: Sequence[int] | None = vert_indices+ self.vert_attributes: tuple[str, ...] | None = vert_data.dtype.names+ self.shader_folder: Path = Path(shader_folder or "")+ self.uniforms: dict[str, float | tuple[float, ...]] = uniforms or {}+ self.texture_paths: Mapping[str, str | Path] = texture_paths or {}+ self.depth_test: bool = depth_test+ self.render_primitive: str = str(render_primitive)self.init_program_code()self.refresh_id()@@ -73,7 +82,7 @@ class ShaderWrapper:result.texture_paths = dict(self.texture_paths)return result- def is_valid(self):+ def is_valid(self) -> bool:return all([self.vert_data is not None,@@ -82,10 +91,10 @@ class ShaderWrapper:],)- def get_id(self):+ def get_id(self) -> str:return self.id- def get_program_id(self):+ def get_program_id(self) -> int:return self.program_iddef create_id(self):@@ -103,9 +112,9 @@ class ShaderWrapper:),)- def refresh_id(self):- self.program_id = self.create_program_id()- self.id = self.create_id()+ def refresh_id(self) -> None:+ self.program_id: int = self.create_program_id()+ self.id: str = self.create_id()def create_program_id(self):return hash(@@ -121,7 +130,7 @@ class ShaderWrapper:self.shader_folder / f"{name}.glsl",)- self.program_code = {+ self.program_code: dict[str, str | None] = {"vertex_shader": get_code("vert"),"geometry_shader": get_code("geom"),"fragment_shader": get_code("frag"),@@ -130,7 +139,7 @@ class ShaderWrapper:def get_program_code(self):return self.program_code- def replace_code(self, old, new):+ def replace_code(self, old: str, new: str) -> None:code_map = self.program_codefor name, _code in code_map.items():if code_map[name] is None:@@ -138,10 +147,10 @@ class ShaderWrapper:code_map[name] = re.sub(old, new, code_map[name])self.refresh_id()- def combine_with(self, *shader_wrappers):+ def combine_with(self, *shader_wrappers: "ShaderWrapper") -> Self: # noqa: UP037# Assume they are of the same typeif len(shader_wrappers) == 0:- return+ return selfif self.vert_indices is not None:num_verts = len(self.vert_data)indices_list = [self.vert_indices]diff --git a/manim/utils/config_ops.py b/manim/utils/config_ops.pyindex 401144d55..cf65d960d 100644--- a/manim/utils/config_ops.py+++ b/manim/utils/config_ops.py@@ -10,9 +10,10 @@ __all__ = [import itertools as it-from typing import Any+from typing import Any, Generic, Protocol, castimport numpy.typing as npt+from typing_extensions import TypeVardef merge_dicts_recursively(*dicts: dict[Any, Any]) -> dict[Any, Any]:@@ -51,33 +52,47 @@ class DictAsObject:self.__dict__ = dictin-class _Data:+_Data_T = TypeVar("_Data_T", bound="npt.NDArray[Any]", default="npt.NDArray[Any]")+++class _HasData(Protocol):+ data: dict[str, npt.NDArray[Any]]+++class _Data(Generic[_Data_T]):"""Descriptor that allows _Data variables to be grouped and accessed from self.data["attr"] via self.attr.self.data attributes must be arrays."""- def __set_name__(self, obj: Any, name: str) -> None:- self.name = name+ def __set_name__(self, obj: _HasData, name: str) -> None:+ self.name: str = name- def __get__(self, obj: Any, owner: Any) -> npt.NDArray[Any]:- value: npt.NDArray[Any] = obj.data[self.name]+ def __get__(self, obj: _HasData, owner: Any) -> _Data_T:+ value = cast(_Data_T, obj.data[self.name])return value- def __set__(self, obj: Any, array: npt.NDArray[Any]) -> None:+ def __set__(self, obj: _HasData, array: _Data_T) -> None:obj.data[self.name] = array-class _Uniforms:+_Uniforms_T = TypeVar("_Uniforms_T", bound="float | tuple[float, ...]", default=float)+++class _HasUniforms(Protocol):+ uniforms: dict[str, float | tuple[float, ...]]+++class _Uniforms(Generic[_Uniforms_T]):"""Descriptor that allows _Uniforms variables to be grouped from self.uniforms["attr"] via self.attr.- self.uniforms attributes must be floats.+ self.uniforms attributes must be floats or tuples of floats."""- def __set_name__(self, obj: Any, name: str) -> None:- self.name = name+ def __set_name__(self, obj: _HasUniforms, name: str) -> None:+ self.name: str = name- def __get__(self, obj: Any, owner: Any) -> float:- val: float = obj.__dict__["uniforms"][self.name]+ def __get__(self, obj: _HasUniforms, owner: Any) -> _Uniforms_T:+ val = cast(_Uniforms_T, obj.uniforms[self.name])return val- def __set__(self, obj: Any, num: float) -> None:- obj.__dict__["uniforms"][self.name] = num+ def __set__(self, obj: _HasUniforms, num: _Uniforms_T) -> None:+ obj.uniforms[self.name] = numdiff --git a/manim/utils/deprecation.py b/manim/utils/deprecation.pyindex b7a5febff..bc356e3f5 100644--- a/manim/utils/deprecation.py+++ b/manim/utils/deprecation.py@@ -250,10 +250,7 @@ def deprecated(if type(func).__name__ != "function":deprecate_docs(func)- # The following line raises this mypy error:- # Accessing "__init__" on an instance is unsound, since instance.__init__- # could be from an incompatible subclass [misc]</pre>- func.__init__ = decorate(func.__init__, deprecate) # type: ignore[method-assign]+ func.__init__ = decorate(func.__init__, deprecate)return funcfunc = decorate(func, deprecate)diff --git a/mypy.ini b/mypy.iniindex 017d32c2d..ca5722a01 100644--- a/mypy.ini+++ b/mypy.ini@@ -5,7 +5,11 @@ python_version = 3.10; plugins = numpy.typing.mypy_pluginignore_errors = Falsecache_fine_grained = True-warn_unused_ignores = True++# Apparently mypy cannot understand the difference between methods and callable attributes.+# See https://github.com/python/mypy/issues/2427#issuecomment-929688736+# and https://github.com/python/mypy/issues/2427#issuecomment-1419206807+disable_error_code = method-assign# Disallow Dynamic Typing# disallow_any_unimported = True@@ -28,7 +32,7 @@ disallow_incomplete_defs = True## # Configuring Warnings# warn_redundant_casts = True-# warn_unused_ignores = True+warn_unused_ignores = Truewarn_return_any = True# warn_unreachable = True#@@ -93,9 +97,6 @@ ignore_errors = True[mypy-manim.mobject.opengl.opengl_image_mobject]ignore_errors = True-[mypy-manim.mobject.opengl.opengl_mobject]-ignore_errors = True-[mypy-manim.mobject.opengl.opengl_point_cloud_mobject]ignore_errors = True