Add type annotations to cairo_renderer.py

manim/renderer/cairo_renderer.py

@@ -41,7 +41,7 @@ def __init__(
         camera_class: type[Camera] | None = None,
         skip_animations: bool = False,
         **kwargs: Any,
-    ) -> None:
+    ):
         # All of the following are set to EITHER the value passed via kwargs,
         # OR the value stored in the global config dict at the time of
         # _instance construction_.
@@ -50,10 +50,10 @@ def __init__(
         self.camera = camera_cls()
         self._original_skipping_status = skip_animations
         self.skip_animations = skip_animations
-        self.animations_hashes = []
+        self.animations_hashes: list[str | None] = []
         self.num_plays = 0
-        self.time = 0
-        self.static_image = None
+        self.time = 0.0
+        self.static_image: PixelArray | None = None
 
     def init_scene(self, scene: Scene) -> None:
         self.file_writer: Any = self._file_writer_class(
@@ -65,8 +65,8 @@ def play(
         self,
         scene: Scene,
         *args: Animation | Mobject | _AnimationBuilder,
-        **kwargs,
-    ):
+        **kwargs: Any,
+    ) -> None:
         # Reset skip_animations to the original state.
         # Needed when rendering only some animations, and skipping others.
         self.skip_animations = self._original_skipping_status
@@ -159,7 +159,12 @@ def update_frame(  # TODO Description in Docstring
         kwargs["include_submobjects"] = include_submobjects
         self.camera.capture_mobjects(mobjects, **kwargs)
 
-    def render(self, scene, time, moving_mobjects):
+    def render(
+        self,
+        scene: Scene,
+        time: float,
+        moving_mobjects: Iterable[Mobject] | None = None,
+    ) -> None:
         self.update_frame(scene, moving_mobjects)
         self.add_frame(self.get_frame())
 
@@ -168,13 +173,13 @@ def get_frame(self) -> PixelArray:
 
         Returns
         -------
-        np.array
+        PixelArray
             NumPy array of pixel values of each pixel in screen.
             The shape of the array is height x width x 3.
         """
         return np.array(self.camera.pixel_array)
 
-    def add_frame(self, frame: np.ndarray, num_frames: int = 1):
+    def add_frame(self, frame: PixelArray, num_frames: int = 1) -> None:
         """Adds a frame to the video_file_stream
 
         Parameters
@@ -190,7 +195,7 @@ def add_frame(self, frame: np.ndarray, num_frames: int = 1):
         self.time += num_frames * dt
         self.file_writer.write_frame(frame, num_frames=num_frames)
 
-    def freeze_current_frame(self, duration: float):
+    def freeze_current_frame(self, duration: float) -> None:
         """Adds a static frame to the movie for a given duration. The static frame is the current frame.
 
         Parameters
@@ -204,16 +209,18 @@ def freeze_current_frame(self, duration: float):
             num_frames=int(duration / dt),
         )
 
-    def show_frame(self):
-        """Opens the current frame in the Default Image Viewer of your system."""
-        self.update_frame(ignore_skipping=True)
+    def show_frame(self, scene: Scene) -> None:
+        """Opens the current frame in the Default Image Viewer
+        of your system.
+        """
+        self.update_frame(scene, ignore_skipping=True)
         self.camera.get_image().show()
 
     def save_static_frame_data(
         self,
         scene: Scene,
         static_mobjects: Iterable[Mobject],
-    ) -> Iterable[Mobject] | None:
+    ) -> PixelArray | None:
         """Compute and save the static frame, that will be reused at each frame
         to avoid unnecessarily computing static mobjects.
 
@@ -226,8 +233,8 @@ def save_static_frame_data(
 
         Returns
         -------
-        typing.Iterable[Mobject]
-            The static image computed.
+        PixelArray | None
+            The static image computed. The return value is None if there are no static mobjects in the scene.
         """
         self.static_image = None
         if not static_mobjects:
@@ -236,9 +243,8 @@ def save_static_frame_data(
         self.static_image = self.get_frame()
         return self.static_image
 
-    def update_skipping_status(self):
-        """
-        This method is used internally to check if the current
+    def update_skipping_status(self) -> None:
+        """This method is used internally to check if the current
         animation needs to be skipped or not. It also checks if
         the number of animations that were played correspond to
         the number of animations that need to be played, and

manim/scene/scene.py

@@ -186,7 +186,7 @@ def __init__(
         self.moving_mobjects: list[Mobject] = []
         self.static_mobjects: list[Mobject] = []
         self.time_progression: tqdm[float] | None = None
-        self.duration: float | None = None
+        self.duration: float = 0.0
         self.last_t = 0.0
         self.queue: Queue[SceneInteractAction] = Queue()
         self.skip_animation_preview = False

manim/utils/hashing.py

@@ -54,22 +54,24 @@
     THRESHOLD_WARNING = 170_000
 
     @classmethod
-    def reset_already_processed(cls):
+    def reset_already_processed(cls: type[_Memoizer]) -> None:
         cls._already_processed.clear()
 
     @classmethod
-    def check_already_processed_decorator(cls: _Memoizer, is_method: bool = False):
+    def check_already_processed_decorator(
+        cls: type[_Memoizer], is_method: bool = False
+    ) -> Callable:
         """Decorator to handle the arguments that goes through the decorated function.
-        Returns _ALREADY_PROCESSED_PLACEHOLDER if the obj has been processed, or lets
-        the decorated function call go ahead.
+        Returns the value of ALREADY_PROCESSED_PLACEHOLDER if the obj has been processed,
+        or lets the decorated function call go ahead.
 
         Parameters
         ----------
         is_method
             Whether the function passed is a method, by default False.
         """
 
-        def layer(func):
+        def layer(func: Callable[[Any], Any]) -> Callable:
             # NOTE : There is probably a better way to separate both case when func is
             # a method or a function.
             if is_method:
@@ -82,9 +84,9 @@
         return layer
 
     @classmethod
-    def check_already_processed(cls, obj: Any) -> Any:
+    def check_already_processed(cls: type[_Memoizer], obj: Any) -> Any:
         """Checks if obj has been already processed. Returns itself if it has not been,
-        or the value of _ALREADY_PROCESSED_PLACEHOLDER if it has.
+        or the value of ALREADY_PROCESSED_PLACEHOLDER if it has.
         Marks the object as processed in the second case.
 
         Parameters
@@ -101,7 +103,7 @@
         return cls._handle_already_processed(obj, lambda x: x)
 
     @classmethod
-    def mark_as_processed(cls, obj: Any) -> None:
+    def mark_as_processed(cls: type[_Memoizer], obj: Any) -> None:
         """Marks an object as processed.
 
         Parameters
@@ -114,10 +116,10 @@
 
     @classmethod
     def _handle_already_processed(
-        cls,
-        obj,
+        cls: type[_Memoizer],
+        obj: Any,
         default_function: Callable[[Any], Any],
-    ):
+    ) -> str | Any:
         if isinstance(
             obj,
             (
@@ -142,11 +144,11 @@
 
     @classmethod
     def _return(
-        cls,
+        cls: type[_Memoizer],
         obj: Any,
         obj_to_membership_sign: Callable[[Any], int],
-        default_func,
-        memoizing=True,
+        default_func: Callable[[Any], Any],
+        memoizing: bool = True,
     ) -> str | Any:
         obj_membership_sign = obj_to_membership_sign(obj)
         if obj_membership_sign in cls._already_processed:
@@ -172,9 +174,8 @@
 
 
 class _CustomEncoder(json.JSONEncoder):
-    def default(self, obj: Any):
-        """
-        This method is used to serialize objects to JSON format.
+    def default(self, obj: Any) -> Any:
+        """This method is used to serialize objects to JSON format.
 
         If obj is a function, then it will return a dict with two keys : 'code', for
         the code source, and 'nonlocals' for all nonlocalsvalues. (including nonlocals
@@ -233,22 +234,28 @@
         # Serialize it with only the type of the object. You can change this to whatever string when debugging the serialization process.
         return str(type(obj))
 
-    def _cleaned_iterable(self, iterable: Iterable[Any]):
+    @overload
+    def _cleaned_iterable(self, iterable: Sequence[Any]) -> list[Any]: ...
+
+    @overload
+    def _cleaned_iterable(self, iterable: dict[Any, Any]) -> dict[Any, Any]: ...
+
+    def _cleaned_iterable(self, iterable):
         """Check for circular reference at each iterable that will go through the JSONEncoder, as well as key of the wrong format.
 
         If a key with a bad format is found (i.e not a int, string, or float), it gets replaced byt its hash using the same process implemented here.
-        If a circular reference is found within the iterable, it will be replaced by the string "already processed".
+        If a circular reference is found within the iterable, it will be replaced by the value of ALREADY_PROCESSED_PLACEHOLDER.
 
         Parameters
         ----------
         iterable
             The iterable to check.
         """
 
-        def _key_to_hash(key):
+        def _key_to_hash(key: Any) -> int:
             return zlib.crc32(json.dumps(key, cls=_CustomEncoder).encode())
 
-        def _iter_check_list(lst):
+        def _iter_check_list(lst: Sequence[Any]) -> list[Any]:
             processed_list = [None] * len(lst)
             for i, el in enumerate(lst):
                 el = _Memoizer.check_already_processed(el)
@@ -261,7 +268,7 @@
                 processed_list[i] = new_value
             return processed_list
 
-        def _iter_check_dict(dct):
+        def _iter_check_dict(dct: dict[Any, Any]) -> dict[Any, Any]:
             processed_dict = {}
             for k, v in dct.items():
                 v = _Memoizer.check_already_processed(v)
@@ -285,8 +292,10 @@
             return _iter_check_list(iterable)
         elif isinstance(iterable, dict):
             return _iter_check_dict(iterable)
+        else:
+            raise TypeError("'iterable' is neither an iterable nor a dictionary.")
 
-    def encode(self, obj: Any):
+    def encode(self, obj: Any) -> str:
         """Overriding of :meth:`JSONEncoder.encode`, to make our own process.
 
         Parameters
@@ -305,7 +314,7 @@
         return super().encode(obj)
 
 
-def get_json(obj: dict):
+def get_json(obj: Any) -> str:
     """Recursively serialize `object` to JSON using the :class:`CustomEncoder` class.
 
     Parameters
@@ -324,7 +333,7 @@
 def get_hash_from_play_call(
     scene_object: Scene,
     camera_object: Camera | OpenGLCamera,
-    animations_list: Iterable[Animation],
+    animations_list: Iterable[Animation] | None,
     current_mobjects_list: Iterable[Mobject],
 ) -> str:
     """Take the list of animations and a list of mobjects and output their hashes. This is meant to be used for `scene.play` function.

mypy.ini

@@ -126,9 +126,6 @@ ignore_errors = True
 [mypy-manim.mobject.vector_field]
 ignore_errors = True
 
-[mypy-manim.renderer.cairo_renderer]
-ignore_errors = True
-
 [mypy-manim.renderer.opengl_renderer]
 ignore_errors = True