manim 0.17.0__py3-none-any.whl → 0.19.1__py3-none-any.whl

manim/utils/file_ops.py

@@ -28,6 +28,8 @@ from shutil import copyfile
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
+    from manim.typing import StrPath
+
     from ..scene.scene_file_writer import SceneFileWriter
 
 from manim import __version__, config, logger
@@ -45,7 +47,8 @@ def is_mp4_format() -> bool:
         ``True`` if format is set as mp4
 
     """
-    return config["format"] == "mp4"
+    val: bool = config["format"] == "mp4"
+    return val
 
 
 def is_gif_format() -> bool:
@@ -58,7 +61,8 @@ def is_gif_format() -> bool:
         ``True`` if format is set as gif
 
     """
-    return config["format"] == "gif"
+    val: bool = config["format"] == "gif"
+    return val
 
 
 def is_webm_format() -> bool:
@@ -71,7 +75,8 @@ def is_webm_format() -> bool:
         ``True`` if format is set as webm
 
     """
-    return config["format"] == "webm"
+    val: bool = config["format"] == "webm"
+    return val
 
 
 def is_mov_format() -> bool:
@@ -84,7 +89,8 @@ def is_mov_format() -> bool:
         ``True`` if format is set as mov
 
     """
-    return config["format"] == "mov"
+    val: bool = config["format"] == "mov"
+    return val
 
 
 def is_png_format() -> bool:
@@ -97,7 +103,8 @@ def is_png_format() -> bool:
         ``True`` if format is set as png
 
     """
-    return config["format"] == "png"
+    val: bool = config["format"] == "png"
+    return val
 
 
 def write_to_movie() -> bool:
@@ -124,7 +131,7 @@ def write_to_movie() -> bool:
 
 def ensure_executable(path_to_exe: Path) -> bool:
     if path_to_exe.parent == Path("."):
-        executable = shutil.which(path_to_exe.stem)
+        executable: StrPath | None = shutil.which(path_to_exe.stem)
         if executable is None:
             return False
     else:
@@ -159,7 +166,7 @@ def guarantee_empty_existence(path: Path) -> Path:
 
 
 def seek_full_path_from_defaults(
-    file_name: str, default_dir: Path, extensions: list[str]
+    file_name: StrPath, default_dir: Path, extensions: list[str]
 ) -> Path:
     possible_paths = [Path(file_name).expanduser()]
     possible_paths += [
@@ -183,13 +190,15 @@ def modify_atime(file_path: str) -> None:
     file_path
         The path of the file.
     """
-    os.utime(file_path, times=(time.time(), os.path.getmtime(file_path)))
+    os.utime(file_path, times=(time.time(), Path(file_path).stat().st_mtime))
 
 
-def open_file(file_path, in_browser=False):
+def open_file(file_path: Path, in_browser: bool = False) -> None:
     current_os = platform.system()
     if current_os == "Windows":
-        os.startfile(file_path if not in_browser else file_path.parent)
+        # The method os.startfile is only available in Windows,
+        # ignoring type error caused by this.
+        os.startfile(file_path if not in_browser else file_path.parent)  # type: ignore[attr-defined]
     else:
         if current_os == "Linux":
             commands = ["xdg-open"]
@@ -198,14 +207,15 @@ def open_file(file_path, in_browser=False):
             commands = ["cygstart"]
             file_path = file_path if not in_browser else file_path.parent
         elif current_os == "Darwin":
-            if is_gif_format():
-                commands = ["ffplay", "-loglevel", config["ffmpeg_loglevel"].lower()]
-            else:
-                commands = ["open"] if not in_browser else ["open", "-R"]
+            commands = ["open"] if not in_browser else ["open", "-R"]
         else:
             raise OSError("Unable to identify your operating system...")
-        commands.append(file_path)
-        sp.Popen(commands)
+
+        # check after so that file path is set correctly
+        if config.preview_command:
+            commands = [config.preview_command]
+        commands.append(str(file_path))
+        sp.run(commands)
 
 
 def open_media_file(file_writer: SceneFileWriter) -> None:
@@ -248,7 +258,7 @@ def get_template_path() -> Path:
     return Path.resolve(Path(__file__).parent.parent / "templates")
 
 
-def add_import_statement(file: Path):
+def add_import_statement(file: Path) -> None:
     """Prepends an import statement in a file
 
     Parameters

manim/utils/hashing.py

@@ -2,27 +2,28 @@
 
 from __future__ import annotations
 
-import collections
 import copy
 import inspect
 import json
-import typing
 import zlib
+from collections.abc import Callable, Hashable, Iterable, Sequence
 from time import perf_counter
 from types import FunctionType, MappingProxyType, MethodType, ModuleType
-from typing import Any
+from typing import TYPE_CHECKING, Any, overload
 
 import numpy as np
 
-from manim.animation.animation import Animation
-from manim.camera.camera import Camera
-from manim.mobject.mobject import Mobject
+from manim._config import config, logger
 
-from .. import config, logger
-
-if typing.TYPE_CHECKING:
+if TYPE_CHECKING:
+    from manim.animation.animation import Animation
+    from manim.camera.camera import Camera
+    from manim.mobject.mobject import Mobject
+    from manim.renderer.opengl_renderer import OpenGLCamera
     from manim.scene.scene import Scene
 
+__all__ = ["KEYS_TO_FILTER_OUT", "get_hash_from_play_call", "get_json"]
+
 # Sometimes there are elements that are not suitable for hashing (too long or
 # run-dependent).  This is used to filter them out.
 KEYS_TO_FILTER_OUT = {
@@ -53,14 +54,16 @@ class _Memoizer:
     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
         ----------
@@ -68,7 +71,7 @@ class _Memoizer:
             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:
@@ -81,9 +84,9 @@ class _Memoizer:
         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
@@ -100,7 +103,7 @@ class _Memoizer:
         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
@@ -113,10 +116,10 @@ class _Memoizer:
 
     @classmethod
     def _handle_already_processed(
-        cls,
-        obj,
-        default_function: typing.Callable[[Any], Any],
-    ):
+        cls: type[_Memoizer],
+        obj: Any,
+        default_function: Callable[[Any], Any],
+    ) -> str | Any:
         if isinstance(
             obj,
             (
@@ -129,7 +132,7 @@ class _Memoizer:
             # It makes no sense (and it'd slower) to memoize objects of these primitive
             # types.  Hence, we simply return the object.
             return obj
-        if isinstance(obj, collections.abc.Hashable):
+        if isinstance(obj, Hashable):
             try:
                 return cls._return(obj, hash, default_function)
             except TypeError:
@@ -141,11 +144,11 @@ class _Memoizer:
 
     @classmethod
     def _return(
-        cls,
-        obj: typing.Any,
-        obj_to_membership_sign: typing.Callable[[Any], int],
-        default_func,
-        memoizing=True,
+        cls: type[_Memoizer],
+        obj: Any,
+        obj_to_membership_sign: Callable[[Any], int],
+        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:
@@ -171,9 +174,8 @@ class _Memoizer:
 
 
 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
@@ -207,7 +209,7 @@ class _CustomEncoder(json.JSONEncoder):
                     del cvardict[i]
             try:
                 code = inspect.getsource(obj)
-            except OSError:
+            except (OSError, TypeError):
                 # This happens when rendering videos included in the documentation
                 # within doctests and should be replaced by a solution avoiding
                 # hash collision (due to the same, empty, code strings) at some point.
@@ -218,10 +220,10 @@ class _CustomEncoder(json.JSONEncoder):
             if obj.size > 1000:
                 obj = np.resize(obj, (100, 100))
                 return f"TRUNCATED ARRAY: {repr(obj)}"
-            # We return the repr and not a list to avoid the JsonEncoder to iterate over it.
+            # We return the repr and not a list to avoid the JSONEncoder to iterate over it.
             return repr(obj)
         elif hasattr(obj, "__dict__"):
-            temp = getattr(obj, "__dict__")
+            temp = obj.__dict__
             # MappingProxy is scene-caching nightmare. It contains all of the object methods and attributes. We skip it as the mechanism will at some point process the object, but instantiated.
             # Indeed, there is certainly no case where scene-caching will receive only a non instancied object, as this is never used in the library or encouraged to be used user-side.
             if isinstance(temp, MappingProxyType):
@@ -232,11 +234,17 @@ class _CustomEncoder(json.JSONEncoder):
         # 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: typing.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 key with a bad format is found (i.e not a int, string, or float), it gets replaced by its hash using the same process implemented here.
+        If a circular reference is found within the iterable, it will be replaced by the value of ALREADY_PROCESSED_PLACEHOLDER.
 
         Parameters
         ----------
@@ -244,10 +252,10 @@ class _CustomEncoder(json.JSONEncoder):
             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)
@@ -260,13 +268,13 @@ class _CustomEncoder(json.JSONEncoder):
                 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)
                 if k in KEYS_TO_FILTER_OUT:
                     continue
-                # We check if the k is of the right format (supporter by Json)
+                # We check if the k is of the right format (supported by JSON)
                 if not isinstance(k, (str, int, float, bool)) and k is not None:
                     k_new = _key_to_hash(k)
                 else:
@@ -284,8 +292,10 @@ class _CustomEncoder(json.JSONEncoder):
             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
@@ -304,7 +314,7 @@ class _CustomEncoder(json.JSONEncoder):
         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
@@ -322,9 +332,9 @@ def get_json(obj: dict):
 
 def get_hash_from_play_call(
     scene_object: Scene,
-    camera_object: Camera,
-    animations_list: typing.Iterable[Animation],
-    current_mobjects_list: typing.Iterable[Mobject],
+    camera_object: Camera | OpenGLCamera,
+    animations_list: Iterable[Animation],
+    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.
 

manim/utils/images.py

@@ -9,7 +9,8 @@ __all__ = [
     "change_to_rgba_array",
 ]
 
-from pathlib import Path
+from pathlib import Path, PurePath
+from typing import TYPE_CHECKING
 
 import numpy as np
 from PIL import Image
@@ -17,8 +18,13 @@ from PIL import Image
 from .. import config
 from ..utils.file_ops import seek_full_path_from_defaults
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
 
-def get_full_raster_image_path(image_file_name: str) -> Path:
+    from manim.typing import PixelArray, RGBAPixelArray, RGBPixelArray
+
+
+def get_full_raster_image_path(image_file_name: str | PurePath) -> Path:
     return seek_full_path_from_defaults(
         image_file_name,
         default_dir=config.get_dir("assets_dir"),
@@ -26,7 +32,7 @@ def get_full_raster_image_path(image_file_name: str) -> Path:
     )
 
 
-def get_full_vector_image_path(image_file_name: str) -> Path:
+def get_full_vector_image_path(image_file_name: str | PurePath) -> Path:
     return seek_full_path_from_defaults(
         image_file_name,
         default_dir=config.get_dir("assets_dir"),
@@ -34,22 +40,22 @@ def get_full_vector_image_path(image_file_name: str) -> Path:
     )
 
 
-def drag_pixels(frames: list[np.array]) -> list[np.array]:
+def drag_pixels(frames: Sequence[PixelArray]) -> list[np.ndarray]:
     curr = frames[0]
-    new_frames = []
+    new_frames: list[np.ndarray] = []
     for frame in frames:
         curr += (curr == 0) * np.array(frame)
         new_frames.append(np.array(curr))
     return new_frames
 
 
-def invert_image(image: np.array) -> Image:
+def invert_image(image: PixelArray) -> Image:
     arr = np.array(image)
     arr = (255 * np.ones(arr.shape)).astype(arr.dtype) - arr
     return Image.fromarray(arr)
 
 
-def change_to_rgba_array(image, dtype="uint8"):
+def change_to_rgba_array(image: RGBPixelArray, dtype: str = "uint8") -> RGBAPixelArray:
     """Converts an RGB array into RGBA with the alpha value opacity maxed."""
     pa = image
     if len(pa.shape) == 2:

manim/utils/ipython_magic.py

@@ -3,18 +3,19 @@
 from __future__ import annotations
 
 import mimetypes
-import os
 import shutil
 from datetime import datetime
 from pathlib import Path
 from typing import Any
 
-from manim import Group, config, logger, tempconfig
+from manim import config, logger, tempconfig
 from manim.__main__ import main
 from manim.renderer.shader import shader_program_cache
 
 from ..constants import RendererType
 
+__all__ = ["ManimMagic"]
+
 try:
     from IPython import get_ipython
     from IPython.core.interactiveshell import InteractiveShell
@@ -33,15 +34,15 @@ else:
     class ManimMagic(Magics):
         def __init__(self, shell: InteractiveShell) -> None:
             super().__init__(shell)
-            self.rendered_files = {}
+            self.rendered_files: dict[Path, Path] = {}
 
         @needs_local_scope
         @line_cell_magic
         def manim(
             self,
             line: str,
-            cell: str = None,
-            local_ns: dict[str, Any] = None,
+            cell: str | None = None,
+            local_ns: dict[str, Any] | None = None,
         ) -> None:
             r"""Render Manim scenes contained in IPython cells.
             Works as a line or cell magic.
@@ -126,6 +127,7 @@ else:
 
             modified_args = self.add_additional_args(args)
             args = main(modified_args, standalone_mode=False, prog_name="manim")
+            assert isinstance(local_ns, dict)
             with tempconfig(local_ns.get("config", {})):
                 config.digest_args(args)
 
@@ -166,8 +168,9 @@ else:
                 shutil.copy(local_path, tmpfile)
 
                 file_type = mimetypes.guess_type(config["output_file"])[0]
+                assert isinstance(file_type, str)
                 embed = config["media_embed"]
-                if embed is None:
+                if not embed:
                     # videos need to be embedded when running in google colab.
                     # do this automatically in case config.media_embed has not been
                     # set explicitly.
@@ -193,4 +196,7 @@ else:
 
 
 def _generate_file_name() -> str:
-    return config["scene_names"][0] + "@" + datetime.now().strftime("%Y-%m-%d@%H-%M-%S")
+    val: str = (
+        config["scene_names"][0] + "@" + datetime.now().strftime("%Y-%m-%d@%H-%M-%S")
+    )
+    return val