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

manim/camera/three_d_camera.py

@@ -5,7 +5,8 @@ from __future__ import annotations
 __all__ = ["ThreeDCamera"]
 
 
-from typing import Callable
+from collections.abc import Callable, Iterable
+from typing import Any
 
 import numpy as np
 
@@ -16,7 +17,15 @@ from manim.mobject.three_d.three_d_utils import (
     get_3d_vmob_start_corner,
     get_3d_vmob_start_corner_unit_normal,
 )
+from manim.mobject.types.vectorized_mobject import VMobject
 from manim.mobject.value_tracker import ValueTracker
+from manim.typing import (
+    FloatRGBA_Array,
+    MatrixMN,
+    Point3D,
+    Point3D_Array,
+    Point3DLike,
+)
 
 from .. import config
 from ..camera.camera import Camera
@@ -30,17 +39,17 @@ from ..utils.space_ops import rotation_about_z, rotation_matrix
 class ThreeDCamera(Camera):
     def __init__(
         self,
-        focal_distance=20.0,
-        shading_factor=0.2,
-        default_distance=5.0,
-        light_source_start_point=9 * DOWN + 7 * LEFT + 10 * OUT,
-        should_apply_shading=True,
-        exponential_projection=False,
-        phi=0,
-        theta=-90 * DEGREES,
-        gamma=0,
-        zoom=1,
-        **kwargs,
+        focal_distance: float = 20.0,
+        shading_factor: float = 0.2,
+        default_distance: float = 5.0,
+        light_source_start_point: Point3DLike = 9 * DOWN + 7 * LEFT + 10 * OUT,
+        should_apply_shading: bool = True,
+        exponential_projection: bool = False,
+        phi: float = 0,
+        theta: float = -90 * DEGREES,
+        gamma: float = 0,
+        zoom: float = 1,
+        **kwargs: Any,
     ):
         """Initializes the ThreeDCamera
 
@@ -68,24 +77,25 @@ class ThreeDCamera(Camera):
         self.focal_distance_tracker = ValueTracker(self.focal_distance)
         self.gamma_tracker = ValueTracker(self.gamma)
         self.zoom_tracker = ValueTracker(self.zoom)
-        self.fixed_orientation_mobjects = {}
-        self.fixed_in_frame_mobjects = set()
+        self.fixed_orientation_mobjects: dict[Mobject, Callable[[], Point3D]] = {}
+        self.fixed_in_frame_mobjects: set[Mobject] = set()
         self.reset_rotation_matrix()
 
     @property
-    def frame_center(self):
+    def frame_center(self) -> Point3D:
         return self._frame_center.points[0]
 
     @frame_center.setter
-    def frame_center(self, point):
+    def frame_center(self, point: Point3DLike) -> None:
         self._frame_center.move_to(point)
 
-    def capture_mobjects(self, mobjects, **kwargs):
+    def capture_mobjects(self, mobjects: Iterable[Mobject], **kwargs: Any) -> None:
         self.reset_rotation_matrix()
         super().capture_mobjects(mobjects, **kwargs)
 
-    def get_value_trackers(self):
-        """Returns list of ValueTrackers of phi, theta, focal_distance and gamma
+    def get_value_trackers(self) -> list[ValueTracker]:
+        """A list of :class:`ValueTrackers <.ValueTracker>` of phi, theta, focal_distance,
+        gamma and zoom.
 
         Returns
         -------
@@ -100,7 +110,9 @@ class ThreeDCamera(Camera):
             self.zoom_tracker,
         ]
 
-    def modified_rgbas(self, vmobject, rgbas):
+    def modified_rgbas(
+        self, vmobject: VMobject, rgbas: FloatRGBA_Array
+    ) -> FloatRGBA_Array:
         if not self.should_apply_shading:
             return rgbas
         if vmobject.shade_in_3d and (vmobject.get_num_points() > 0):
@@ -126,28 +138,33 @@ class ThreeDCamera(Camera):
 
     def get_stroke_rgbas(
         self,
-        vmobject,
-        background=False,
-    ):  # NOTE : DocStrings From parent
+        vmobject: VMobject,
+        background: bool = False,
+    ) -> FloatRGBA_Array:  # NOTE : DocStrings From parent
         return self.modified_rgbas(vmobject, vmobject.get_stroke_rgbas(background))
 
-    def get_fill_rgbas(self, vmobject):  # NOTE : DocStrings From parent
+    def get_fill_rgbas(
+        self, vmobject: VMobject
+    ) -> FloatRGBA_Array:  # NOTE : DocStrings From parent
         return self.modified_rgbas(vmobject, vmobject.get_fill_rgbas())
 
-    def get_mobjects_to_display(self, *args, **kwargs):  # NOTE : DocStrings From parent
+    def get_mobjects_to_display(
+        self, *args: Any, **kwargs: Any
+    ) -> list[Mobject]:  # NOTE : DocStrings From parent
         mobjects = super().get_mobjects_to_display(*args, **kwargs)
         rot_matrix = self.get_rotation_matrix()
 
-        def z_key(mob):
+        def z_key(mob: Mobject) -> float:
             if not (hasattr(mob, "shade_in_3d") and mob.shade_in_3d):
-                return np.inf
+                return np.inf  # type: ignore[no-any-return]
             # Assign a number to a three dimensional mobjects
             # based on how close it is to the camera
-            return np.dot(mob.get_z_index_reference_point(), rot_matrix.T)[2]
+            distance: float = np.dot(mob.get_z_index_reference_point(), rot_matrix.T)[2]
+            return distance
 
         return sorted(mobjects, key=z_key)
 
-    def get_phi(self):
+    def get_phi(self) -> float:
         """Returns the Polar angle (the angle off Z_AXIS) phi.
 
         Returns
@@ -157,7 +174,7 @@ class ThreeDCamera(Camera):
         """
         return self.phi_tracker.get_value()
 
-    def get_theta(self):
+    def get_theta(self) -> float:
         """Returns the Azimuthal i.e the angle that spins the camera around the Z_AXIS.
 
         Returns
@@ -167,7 +184,7 @@ class ThreeDCamera(Camera):
         """
         return self.theta_tracker.get_value()
 
-    def get_focal_distance(self):
+    def get_focal_distance(self) -> float:
         """Returns focal_distance of the Camera.
 
         Returns
@@ -177,7 +194,7 @@ class ThreeDCamera(Camera):
         """
         return self.focal_distance_tracker.get_value()
 
-    def get_gamma(self):
+    def get_gamma(self) -> float:
         """Returns the rotation of the camera about the vector from the ORIGIN to the Camera.
 
         Returns
@@ -188,7 +205,7 @@ class ThreeDCamera(Camera):
         """
         return self.gamma_tracker.get_value()
 
-    def get_zoom(self):
+    def get_zoom(self) -> float:
         """Returns the zoom amount of the camera.
 
         Returns
@@ -198,7 +215,7 @@ class ThreeDCamera(Camera):
         """
         return self.zoom_tracker.get_value()
 
-    def set_phi(self, value: float):
+    def set_phi(self, value: float) -> None:
         """Sets the polar angle i.e the angle between Z_AXIS and Camera through ORIGIN in radians.
 
         Parameters
@@ -208,7 +225,7 @@ class ThreeDCamera(Camera):
         """
         self.phi_tracker.set_value(value)
 
-    def set_theta(self, value: float):
+    def set_theta(self, value: float) -> None:
         """Sets the azimuthal angle i.e the angle that spins the camera around Z_AXIS in radians.
 
         Parameters
@@ -218,7 +235,7 @@ class ThreeDCamera(Camera):
         """
         self.theta_tracker.set_value(value)
 
-    def set_focal_distance(self, value: float):
+    def set_focal_distance(self, value: float) -> None:
         """Sets the focal_distance of the Camera.
 
         Parameters
@@ -228,7 +245,7 @@ class ThreeDCamera(Camera):
         """
         self.focal_distance_tracker.set_value(value)
 
-    def set_gamma(self, value: float):
+    def set_gamma(self, value: float) -> None:
         """Sets the angle of rotation of the camera about the vector from the ORIGIN to the Camera.
 
         Parameters
@@ -238,7 +255,7 @@ class ThreeDCamera(Camera):
         """
         self.gamma_tracker.set_value(value)
 
-    def set_zoom(self, value: float):
+    def set_zoom(self, value: float) -> None:
         """Sets the zoom amount of the camera.
 
         Parameters
@@ -248,13 +265,13 @@ class ThreeDCamera(Camera):
         """
         self.zoom_tracker.set_value(value)
 
-    def reset_rotation_matrix(self):
+    def reset_rotation_matrix(self) -> None:
         """Sets the value of self.rotation_matrix to
         the matrix corresponding to the current position of the camera
         """
         self.rotation_matrix = self.generate_rotation_matrix()
 
-    def get_rotation_matrix(self):
+    def get_rotation_matrix(self) -> MatrixMN:
         """Returns the matrix corresponding to the current position of the camera.
 
         Returns
@@ -264,7 +281,7 @@ class ThreeDCamera(Camera):
         """
         return self.rotation_matrix
 
-    def generate_rotation_matrix(self):
+    def generate_rotation_matrix(self) -> MatrixMN:
         """Generates a rotation matrix based off the current position of the camera.
 
         Returns
@@ -285,7 +302,7 @@ class ThreeDCamera(Camera):
             result = np.dot(matrix, result)
         return result
 
-    def project_points(self, points: np.ndarray | list):
+    def project_points(self, points: Point3D_Array) -> Point3D_Array:
         """Applies the current rotation_matrix as a projection
         matrix to the passed array of points.
 
@@ -322,7 +339,7 @@ class ThreeDCamera(Camera):
             points[:, i] *= factor * zoom
         return points
 
-    def project_point(self, point: list | np.ndarray):
+    def project_point(self, point: Point3D) -> Point3D:
         """Applies the current rotation_matrix as a projection
         matrix to the passed point.
 
@@ -340,9 +357,9 @@ class ThreeDCamera(Camera):
 
     def transform_points_pre_display(
         self,
-        mobject,
-        points,
-    ):  # TODO: Write Docstrings for this Method.
+        mobject: Mobject,
+        points: Point3D_Array,
+    ) -> Point3D_Array:  # TODO: Write Docstrings for this Method.
         points = super().transform_points_pre_display(mobject, points)
         fixed_orientation = mobject in self.fixed_orientation_mobjects
         fixed_in_frame = mobject in self.fixed_in_frame_mobjects
@@ -361,8 +378,8 @@ class ThreeDCamera(Camera):
         self,
         *mobjects: Mobject,
         use_static_center_func: bool = False,
-        center_func: Callable[[], np.ndarray] | None = None,
-    ):
+        center_func: Callable[[], Point3D] | None = None,
+    ) -> None:
         """This method allows the mobject to have a fixed orientation,
         even when the camera moves around.
         E.G If it was passed through this method, facing the camera, it
@@ -380,9 +397,10 @@ class ThreeDCamera(Camera):
             The function which returns the centerpoint
             with respect to which the mobject will be oriented, by default None
         """
+
         # This prevents the computation of mobject.get_center
         # every single time a projection happens
-        def get_static_center_func(mobject):
+        def get_static_center_func(mobject: Mobject) -> Callable[[], Point3D]:
             point = mobject.get_center()
             return lambda: point
 
@@ -396,7 +414,7 @@ class ThreeDCamera(Camera):
             for submob in mobject.get_family():
                 self.fixed_orientation_mobjects[submob] = func
 
-    def add_fixed_in_frame_mobjects(self, *mobjects: Mobject):
+    def add_fixed_in_frame_mobjects(self, *mobjects: Mobject) -> None:
         """This method allows the mobject to have a fixed position,
         even when the camera moves around.
         E.G If it was passed through this method, at the top of the frame, it
@@ -412,7 +430,7 @@ class ThreeDCamera(Camera):
         for mobject in extract_mobject_family_members(mobjects):
             self.fixed_in_frame_mobjects.add(mobject)
 
-    def remove_fixed_orientation_mobjects(self, *mobjects: Mobject):
+    def remove_fixed_orientation_mobjects(self, *mobjects: Mobject) -> None:
         """If a mobject was fixed in its orientation by passing it through
         :meth:`.add_fixed_orientation_mobjects`, then this undoes that fixing.
         The Mobject will no longer have a fixed orientation.
@@ -426,7 +444,7 @@ class ThreeDCamera(Camera):
             if mobject in self.fixed_orientation_mobjects:
                 del self.fixed_orientation_mobjects[mobject]
 
-    def remove_fixed_in_frame_mobjects(self, *mobjects: Mobject):
+    def remove_fixed_in_frame_mobjects(self, *mobjects: Mobject) -> None:
         """If a mobject was fixed in frame by passing it through
         :meth:`.add_fixed_in_frame_mobjects`, then this undoes that fixing.
         The Mobject will no longer be fixed in frame.

manim/cli/__init__.py

@@ -0,0 +1,17 @@
+"""The Manim CLI, and the available commands for ``manim``.
+
+This page is a work in progress. Please run ``manim`` or ``manim --help`` in
+your terminal to find more information on the following commands.
+
+Available commands
+------------------
+
+.. autosummary::
+   :toctree: ../reference
+
+   cfg
+   checkhealth
+   init
+   plugins
+   render
+"""

manim/cli/cfg/group.py

@@ -5,32 +5,45 @@ cfg``. Here you can specify options, subcommands, and subgroups for the cfg
 group.
 
 """
+
 from __future__ import annotations
 
-import os
+import contextlib
 from ast import literal_eval
 from pathlib import Path
+from typing import Any, cast
 
-import click
 import cloup
 from rich.errors import StyleSyntaxError
 from rich.style import Style
 
-from ... import cli_ctx_settings, console
-from ..._config.utils import config_file_paths, make_config_parser
-from ...constants import EPILOG
-from ...utils.file_ops import guarantee_existence, open_file
+from manim._config import cli_ctx_settings, console
+from manim._config.utils import config_file_paths, make_config_parser
+from manim.constants import EPILOG
+from manim.utils.file_ops import guarantee_existence, open_file
 
 RICH_COLOUR_INSTRUCTIONS: str = """
 [red]The default colour is used by the input statement.
 If left empty, the default colour will be used.[/red]
 [magenta] For a full list of styles, visit[/magenta] [green]https://rich.readthedocs.io/en/latest/style.html[/green]
 """
-RICH_NON_STYLE_ENTRIES: str = ["log.width", "log.height", "log.timestamps"]
+RICH_NON_STYLE_ENTRIES: list[str] = ["log.width", "log.height", "log.timestamps"]
+
+__all__ = [
+    "value_from_string",
+    "value_from_string",
+    "is_valid_style",
+    "replace_keys",
+    "cfg",
+    "write",
+    "show",
+    "export",
+]
 
 
 def value_from_string(value: str) -> str | int | bool:
-    """Extracts the literal of proper datatype from a string.
+    """Extract the literal of proper datatype from a ``value`` string.
+
     Parameters
     ----------
     value
@@ -38,51 +51,60 @@ def value_from_string(value: str) -> str | int | bool:
 
     Returns
     -------
-    Union[:class:`str`, :class:`int`, :class:`bool`]
-        Returns the literal of appropriate datatype.
+    :class:`str` | :class:`int` | :class:`bool`
+        The literal of appropriate datatype.
     """
-    try:
+    with contextlib.suppress(SyntaxError, ValueError):
         value = literal_eval(value)
-    except (SyntaxError, ValueError):
-        pass
     return value
 
 
-def _is_expected_datatype(value: str, expected: str, style: bool = False) -> bool:
-    """Checks whether `value` is the same datatype as `expected`,
-    and checks if it is a valid `style` if `style` is true.
+def _is_expected_datatype(
+    value: str, expected: str, validate_style: bool = False
+) -> bool:
+    """Check whether the literal from ``value`` is the same datatype as the
+    literal from ``expected``. If ``validate_style`` is ``True``, also check if
+    the style given by ``value`` is valid, according to ``rich``.
 
     Parameters
     ----------
     value
-        The string of the value to check (obtained from reading the user input).
+        The string of the value to check, obtained from reading the user input.
     expected
-        The string of the literal datatype must be matched by `value`. Obtained from
-        reading the cfg file.
-    style
-        Whether or not to confirm if `value` is a style, by default False
+        The string of the literal datatype which must be matched by ``value``.
+        This is obtained from reading the ``cfg`` file.
+    validate_style
+        Whether or not to confirm if ``value`` is a valid style, according to
+        ``rich``. Default is ``False``.
 
     Returns
     -------
     :class:`bool`
-        Whether or not `value` matches the datatype of `expected`.
+        Whether or not the literal from ``value`` matches the datatype of the
+        literal from ``expected``.
     """
-    value = value_from_string(value)
-    expected = type(value_from_string(expected))
+    value_literal = value_from_string(value)
+    ExpectedLiteralType = type(value_from_string(expected))
 
-    return isinstance(value, expected) and (is_valid_style(value) if style else True)
+    return isinstance(value_literal, ExpectedLiteralType) and (
+        (isinstance(value_literal, str) and is_valid_style(value_literal))
+        if validate_style
+        else True
+    )
 
 
 def is_valid_style(style: str) -> bool:
-    """Checks whether the entered color is a valid color according to rich
+    """Checks whether the entered color style is valid, according to ``rich``.
+
     Parameters
     ----------
     style
         The style to check whether it is valid.
+
     Returns
     -------
-    Boolean
-        Returns whether it is valid style or not according to rich.
+    :class:`bool`
+        Whether the color style is valid or not, according to ``rich``.
     """
     try:
         Style.parse(style)
@@ -91,16 +113,20 @@ def is_valid_style(style: str) -> bool:
         return False
 
 
-def replace_keys(default: dict) -> dict:
-    """Replaces _ to . and vice versa in a dictionary for rich
+def replace_keys(default: dict[str, Any]) -> dict[str, Any]:
+    """Replace ``_`` with ``.`` and vice versa in a dictionary's keys for
+    ``rich``.
+
     Parameters
     ----------
     default
-        The dictionary to check and replace
+        The dictionary whose keys will be checked and replaced.
+
     Returns
     -------
     :class:`dict`
-        The dictionary which is modified by replacing _ with . and vice versa
+        The dictionary whose keys are modified by replacing ``_`` with ``.``
+        and vice versa.
     """
     for key in default:
         if "_" in key:
@@ -123,22 +149,22 @@ def replace_keys(default: dict) -> dict:
     epilog=EPILOG,
     help="Manages Manim configuration files.",
 )
-@click.pass_context
-def cfg(ctx):
+@cloup.pass_context
+def cfg(ctx: cloup.Context) -> None:
     """Responsible for the cfg subcommand."""
     pass
 
 
 @cfg.command(context_settings=cli_ctx_settings, no_args_is_help=True)
-@click.option(
+@cloup.option(
     "-l",
     "--level",
-    type=click.Choice(["user", "cwd"], case_sensitive=False),
+    type=cloup.Choice(["user", "cwd"], case_sensitive=False),
     default="cwd",
     help="Specify if this config is for user or the working directory.",
 )
-@click.option("-o", "--open", "openfile", is_flag=True)
-def write(level: str = None, openfile: bool = False) -> None:
+@cloup.option("-o", "--open", "openfile", is_flag=True)
+def write(level: str | None = None, openfile: bool = False) -> None:
     config_paths = config_file_paths()
     console.print(
         "[yellow bold]Manim Configuration File Writer[/yellow bold]",
@@ -157,7 +183,7 @@ To save your config please save that file and place it in your current working d
         action = "save this as"
         for category in parser:
             console.print(f"{category}", style="bold green underline")
-            default = parser[category]
+            default = cast(dict[str, Any], parser[category])
             if category == "logger":
                 console.print(RICH_COLOUR_INSTRUCTIONS)
                 default = replace_keys(default)
@@ -187,7 +213,7 @@ To save your config please save that file and place it in your current working d
                         """Not enough values in input.
 You may have added a new entry to default.cfg, in which case you will have to
 modify write_cfg_subcmd_input to account for it.""",
-                    )
+                    ) from None
                 if temp:
                     while temp and not _is_expected_datatype(
                         temp,
@@ -240,7 +266,13 @@ modify write_cfg_subcmd_input to account for it.""",
 
 
 @cfg.command(context_settings=cli_ctx_settings)
-def show():
+def show() -> None:
+    console.print("CONFIG FILES READ", style="bold green underline")
+    for path in config_file_paths():
+        if path.exists():
+            console.print(f"{path}")
+    console.print()
+
     parser = make_config_parser()
     rich_non_style_entries = [a.replace(".", "_") for a in RICH_NON_STYLE_ENTRIES]
     for category in parser:
@@ -258,9 +290,9 @@ def show():
 
 
 @cfg.command(context_settings=cli_ctx_settings)
-@click.option("-d", "--directory", default=Path.cwd())
-@click.pass_context
-def export(ctx, directory):
+@cloup.option("-d", "--directory", default=Path.cwd())
+@cloup.pass_context
+def export(ctx: cloup.Context, directory: str) -> None:
     directory_path = Path(directory)
     if directory_path.absolute == Path.cwd().absolute:
         console.print(