manim 0.17.3__py3-none-any.whl → 0.18.0.post0__py3-none-any.whl

manim/mobject/vector_field.py

@@ -14,7 +14,6 @@ from math import ceil, floor
 from typing import Callable, Iterable, Sequence
 
 import numpy as np
-from colour import Color
 from PIL import Image
 
 from manim.animation.updaters.update import UpdateFromAlphaFunc
@@ -30,7 +29,16 @@ from ..mobject.mobject import Mobject
 from ..mobject.types.vectorized_mobject import VGroup
 from ..mobject.utils import get_vectorized_mobject_class
 from ..utils.bezier import interpolate, inverse_interpolate
-from ..utils.color import BLUE_E, GREEN, RED, YELLOW, color_to_rgb, rgb_to_color
+from ..utils.color import (
+    BLUE_E,
+    GREEN,
+    RED,
+    YELLOW,
+    ManimColor,
+    ParsableManimColor,
+    color_to_rgb,
+    rgb_to_color,
+)
 from ..utils.rate_functions import ease_out_sine, linear
 from ..utils.simple_functions import sigmoid
 
@@ -66,11 +74,11 @@ class VectorField(VGroup):
     def __init__(
         self,
         func: Callable[[np.ndarray], np.ndarray],
-        color: Color | None = None,
+        color: ParsableManimColor | None = None,
         color_scheme: Callable[[np.ndarray], float] | None = None,
         min_color_scheme_value: float = 0,
         max_color_scheme_value: float = 2,
-        colors: Sequence[Color] = DEFAULT_SCALAR_FIELD_COLORS,
+        colors: Sequence[ParsableManimColor] = DEFAULT_SCALAR_FIELD_COLORS,
         **kwargs,
     ):
         super().__init__(**kwargs)
@@ -107,7 +115,7 @@ class VectorField(VGroup):
             self.pos_to_color = lambda pos: rgb_to_color(self.pos_to_rgb(pos))
         else:
             self.single_color = True
-            self.color = color
+            self.color = ManimColor.parse(color)
         self.submob_movement_updater = None
 
     @staticmethod
@@ -409,7 +417,7 @@ class VectorField(VGroup):
         self,
         start: float,
         end: float,
-        colors: Iterable,
+        colors: Iterable[ParsableManimColor],
     ):
         """
         Generates a gradient of rgbas as a numpy array
@@ -533,11 +541,11 @@ class ArrowVectorField(VectorField):
     def __init__(
         self,
         func: Callable[[np.ndarray], np.ndarray],
-        color: Color | None = None,
+        color: ParsableManimColor | None = None,
         color_scheme: Callable[[np.ndarray], float] | None = None,
         min_color_scheme_value: float = 0,
         max_color_scheme_value: float = 2,
-        colors: Sequence[Color] = DEFAULT_SCALAR_FIELD_COLORS,
+        colors: Sequence[ParsableManimColor] = DEFAULT_SCALAR_FIELD_COLORS,
         # Determining Vector positions:
         x_range: Sequence[float] = None,
         y_range: Sequence[float] = None,
@@ -613,7 +621,7 @@ class ArrowVectorField(VectorField):
             The root point of the vector.
 
         """
-        output = np.asarray(self.func(point))
+        output = np.array(self.func(point))
         norm = np.linalg.norm(output)
         if norm != 0:
             output *= self.length_func(norm) / norm
@@ -707,11 +715,11 @@ class StreamLines(VectorField):
     def __init__(
         self,
         func: Callable[[np.ndarray], np.ndarray],
-        color: Color | None = None,
+        color: ParsableManimColor | None = None,
         color_scheme: Callable[[np.ndarray], float] | None = None,
         min_color_scheme_value: float = 0,
         max_color_scheme_value: float = 2,
-        colors: Sequence[Color] = DEFAULT_SCALAR_FIELD_COLORS,
+        colors: Sequence[ParsableManimColor] = DEFAULT_SCALAR_FIELD_COLORS,
         # Determining stream line starting positions:
         x_range: Sequence[float] = None,
         y_range: Sequence[float] = None,

manim/plugins/import_plugins.py

@@ -9,7 +9,7 @@ from .. import config, logger
 __all__ = []
 
 
-plugins_requested: list = config["plugins"]
+plugins_requested: list[str] = config["plugins"]
 if "" in plugins_requested:
     plugins_requested.remove("")
 for plugin in pkg_resources.iter_entry_points("manim.plugins"):

manim/plugins/plugins_flags.py

@@ -1,9 +1,4 @@
-"""
-plugins_flags.py
-------------
-
-Plugin Managing Utility.
-"""
+"""Plugin Managing Utility"""
 
 from __future__ import annotations
 

manim/renderer/shader.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import inspect
 import re
 import textwrap
 from pathlib import Path
@@ -9,7 +10,6 @@ import numpy as np
 
 from .. import config
 from ..utils import opengl
-from ..utils.simple_functions import get_parameters
 
 SHADER_FOLDER = Path(__file__).parent / "shaders"
 shader_program_cache: dict = {}
@@ -199,7 +199,7 @@ class Object3D:
         return self.time_based_updaters + self.non_time_updaters
 
     def add_updater(self, update_function, index=None, call_updater=True):
-        if "dt" in get_parameters(update_function):
+        if "dt" in inspect.signature(update_function).parameters:
             updater_list = self.time_based_updaters
         else:
             updater_list = self.non_time_updaters

manim/scene/scene.py

@@ -385,10 +385,8 @@ class Scene:
                 or self.updaters
                 or wait_animation.stop_condition is not None
                 or any(
-                    [
-                        mob.has_time_based_updater()
-                        for mob in self.get_mobject_family_members()
-                    ],
+                    mob.has_time_based_updater()
+                    for mob in self.get_mobject_family_members()
                 )
             )
             wait_animation.is_static_wait = not should_update
@@ -1319,12 +1317,20 @@ class Scene:
             # Allow for calling scene methods without prepending 'self.'.
             local_namespace[method] = embedded_method
 
+        from sqlite3 import connect
+
+        from IPython.core.getipython import get_ipython
         from IPython.terminal.embed import InteractiveShellEmbed
         from traitlets.config import Config
 
         cfg = Config()
         cfg.TerminalInteractiveShell.confirm_exit = False
-        shell = InteractiveShellEmbed(config=cfg)
+        if get_ipython() is None:
+            shell = InteractiveShellEmbed.instance(config=cfg)
+        else:
+            shell = InteractiveShellEmbed(config=cfg)
+        hist = get_ipython().history_manager
+        hist.db = connect(hist.hist_file, check_same_thread=False)
 
         keyboard_thread = threading.Thread(
             target=ipython,
@@ -1524,8 +1530,10 @@ class Scene:
         subtitle = srt.Subtitle(
             index=len(self.renderer.file_writer.subcaptions),
             content=content,
-            start=datetime.timedelta(seconds=self.renderer.time + offset),
-            end=datetime.timedelta(seconds=self.renderer.time + offset + duration),
+            start=datetime.timedelta(seconds=float(self.renderer.time + offset)),
+            end=datetime.timedelta(
+                seconds=float(self.renderer.time + offset + duration)
+            ),
         )
         self.renderer.file_writer.subcaptions.append(subtitle)
 

manim/scene/scene_file_writer.py

@@ -700,9 +700,8 @@ class SceneFileWriter:
             )
             oldest_files_to_delete = sorted(
                 cached_partial_movies,
-                key=os.path.getatime,
+                key=lambda path: path.stat().st_atime,
             )[:number_files_to_delete]
-            # oldest_file_path = min(cached_partial_movies, key=os.path.getatime)
             for file_to_delete in oldest_files_to_delete:
                 file_to_delete.unlink()
             logger.info(

manim/scene/three_d_scene.py

@@ -329,7 +329,7 @@ class ThreeDScene(Scene):
         camera_mobjects = self.renderer.camera.get_value_trackers() + [
             self.renderer.camera._frame_center,
         ]
-        if any([cm in moving_mobjects for cm in camera_mobjects]):
+        if any(cm in moving_mobjects for cm in camera_mobjects):
             return self.mobjects
         return moving_mobjects
 

manim/scene/vector_space_scene.py

@@ -7,7 +7,6 @@ __all__ = ["VectorScene", "LinearTransformationScene"]
 from typing import Callable
 
 import numpy as np
-from colour import Color
 
 from manim.mobject.geometry.arc import Dot
 from manim.mobject.geometry.line import Arrow, Line, Vector
@@ -28,7 +27,17 @@ from ..mobject.matrix import Matrix
 from ..mobject.mobject import Mobject
 from ..mobject.types.vectorized_mobject import VGroup, VMobject
 from ..scene.scene import Scene
-from ..utils.color import BLUE_D, GREEN_C, GREY, RED_C, WHITE, YELLOW
+from ..utils.color import (
+    BLACK,
+    BLUE_D,
+    GREEN_C,
+    GREY,
+    RED_C,
+    WHITE,
+    YELLOW,
+    ManimColor,
+    ParsableManimColor,
+)
 from ..utils.rate_functions import rush_from, rush_into
 from ..utils.space_ops import angle_of_vector
 
@@ -558,11 +567,12 @@ class LinearTransformationScene(VectorScene):
     .. manim:: LinearTransformationSceneExample
 
         class LinearTransformationSceneExample(LinearTransformationScene):
-            def __init__(self):
+            def __init__(self, **kwargs):
                 LinearTransformationScene.__init__(
                     self,
                     show_coordinates=True,
                     leave_ghost_vectors=True,
+                    *kwargs
                 )
 
             def construct(self):
@@ -580,8 +590,8 @@ class LinearTransformationScene(VectorScene):
         show_coordinates: bool = False,
         show_basis_vectors: bool = True,
         basis_vector_stroke_width: float = 6,
-        i_hat_color: Color = X_COLOR,
-        j_hat_color: Color = Y_COLOR,
+        i_hat_color: ParsableManimColor = X_COLOR,
+        j_hat_color: ParsableManimColor = Y_COLOR,
         leave_ghost_vectors: bool = False,
         **kwargs,
     ):
@@ -592,8 +602,8 @@ class LinearTransformationScene(VectorScene):
         self.show_coordinates = show_coordinates
         self.show_basis_vectors = show_basis_vectors
         self.basis_vector_stroke_width = basis_vector_stroke_width
-        self.i_hat_color = i_hat_color
-        self.j_hat_color = j_hat_color
+        self.i_hat_color = ManimColor(i_hat_color)
+        self.j_hat_color = ManimColor(j_hat_color)
         self.leave_ghost_vectors = leave_ghost_vectors
         self.background_plane_kwargs = {
             "color": GREY,

manim/typing.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+from os import PathLike
+from typing import Callable, Tuple, Union
+
+import numpy as np
+import numpy.typing as npt
+from typing_extensions import TypeAlias
+
+# Color Types
+
+ManimFloat: TypeAlias = np.float64
+ManimInt: TypeAlias = np.int64
+ManimColorDType: TypeAlias = ManimFloat
+
+RGB_Array_Float: TypeAlias = npt.NDArray[ManimFloat]
+RGB_Tuple_Float: TypeAlias = Tuple[float, float, float]
+
+RGB_Array_Int: TypeAlias = npt.NDArray[ManimInt]
+RGB_Tuple_Int: TypeAlias = Tuple[int, int, int]
+
+RGBA_Array_Float: TypeAlias = npt.NDArray[ManimFloat]
+RGBA_Tuple_Float: TypeAlias = Tuple[float, float, float, float]
+
+RGBA_Array_Int: TypeAlias = npt.NDArray[ManimInt]
+RGBA_Tuple_Int: TypeAlias = Tuple[int, int, int, int]
+
+HSV_Array_Float: TypeAlias = RGB_Array_Float
+HSV_Tuple_Float: TypeAlias = RGB_Tuple_Float
+
+ManimColorInternal: TypeAlias = npt.NDArray[ManimColorDType]
+
+# Point Types
+
+PointDType: TypeAlias = ManimFloat
+""" DType for all points. """
+
+InternalPoint2D: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (2,)` A 2D point. `[float, float]`.
+This type alias is mostly made available for internal use and only includes the numpy type.
+"""
+
+Point2D: TypeAlias = Union[InternalPoint2D, Tuple[float, float]]
+""" `shape: (2,)` A 2D point. `[float, float]`. """
+
+InternalPoint3D: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (3,)` A 3D point. `[float, float, float]`.
+This type alias is mostly made available for internal use and only includes the numpy type.
+"""
+
+Point3D: TypeAlias = Union[InternalPoint3D, Tuple[float, float, float]]
+""" `shape: (3,)` A 3D point. `[float, float, float]` """
+
+# Bezier Types
+QuadraticBezierPoints: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (3,3)` An Array of Quadratic Bezier Handles `[[float, float, float], [float, float, float], [float, float, float]]`. """
+
+QuadraticBezierPoints_Array: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (N,3,3)` An Array of Quadratic Bezier Handles `[[[float, float, float], [float, float, float], [float, float, float]], ...]`. """
+
+CubicBezierPoints: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (4,3)` An Array of Cubic Bezier Handles `[[float, float, float], [float, float, float], [float, float, float], [float, float, float]]`. """
+
+BezierPoints: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (N,3)` An Array of Cubic Bezier Handles `[[float, float, float], ...]`.
+`N` Is always multiples of the degree of the Bezier curve.
+(Please refer to the documentation of the function you are using for further type Information)
+"""
+
+FlatBezierPoints: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (N)` An Array of Bezier Handles but flattened `[float, ...]`."""
+
+Point2D_Array: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (N,2)` An Array of Points in 2D Space `[[float, float], ...]`.
+
+(Please refer to the documentation of the function you are using for further type Information)
+"""
+
+InternalPoint3D_Array: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (N,3)` An Array of Points in 3D Space `[[float, float, float], ...]`.
+This type alias is mostly made available for internal use and only includes the numpy type.
+"""
+
+Point3D_Array: TypeAlias = Union[
+    InternalPoint3D_Array, Tuple[Tuple[float, float, float], ...]
+]
+""" `shape: (N,3)` An Array of Points in 3D Space `[[float, float, float], ...]`.
+
+(Please refer to the documentation of the function you are using for further type Information)
+"""
+
+BezierPoints_Array: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (N,PPC,3)` An Array of Bezier Handles `[[[float, float, float], ...], ...]`.
+`PPC` Is the number of points per bezier curve. `N` Is the number of bezier curves.
+(Please refer to the documentation of the function you are using for further type Information)
+"""
+
+# Vector Types
+Vector3: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (3,)` A Vector `[float, float, float]`. """
+
+Vector: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (N,)` A Vector `[float, ...]`. """
+
+RowVector: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (1,N)` A Row Vector `[[float, ...]]`. """
+
+ColVector: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (N,1)` A Column Vector `[[float], [float], ...]`. """
+
+MatrixMN: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (M,N)` A Matrix `[[float, ...], [float, ...], ...]`. """
+
+Zeros: TypeAlias = npt.NDArray[ManimFloat]
+"""A Matrix of Zeros. Typically created with `numpy.zeros((M,N))`"""
+
+# Due to current limitations (see https://github.com/python/mypy/issues/14656 / 8263), we don't specify the first argument type (Mobject).
+FunctionOverride: TypeAlias = Callable[..., None]
+"""Function type returning an animation for the specified Mobject."""
+
+
+# Misc
+PathFuncType: TypeAlias = Callable[[Point3D, Point3D, float], Point3D]
+"""Function mapping two points and an alpha value to a new point"""
+
+MappingFunction: TypeAlias = Callable[[Point3D], Point3D]
+"""A function mapping a Point3D to another Point3D"""
+
+Image: TypeAlias = np.ndarray
+"""An Image"""
+
+StrPath: TypeAlias = "str | PathLike[str]"
+StrOrBytesPath: TypeAlias = "str | bytes | PathLike[str] | PathLike[bytes]"