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

manim/mobject/text/tex_mobject.py

@@ -12,6 +12,8 @@ r"""Mobjects representing text rendered using LaTeX.
 
 from __future__ import annotations
 
+from manim.utils.color import ManimColor
+
 __all__ = [
     "SingleStringMathTex",
     "MathTex",
@@ -26,9 +28,7 @@ import operator as op
 import re
 from functools import reduce
 from textwrap import dedent
-from typing import Dict, Iterable, Optional
-
-from colour import Color
+from typing import Iterable
 
 from manim import config, logger
 from manim.constants import *
@@ -38,8 +38,6 @@ from manim.mobject.types.vectorized_mobject import VectorizedPoint, VGroup, VMob
 from manim.utils.tex import TexTemplate
 from manim.utils.tex_file_writing import tex_to_svg_file
 
-SCALE_FACTOR_PER_FONT_POINT = 1 / 960
-
 tex_string_to_mob_map = {}
 
 
@@ -255,7 +253,7 @@ class MathTex(SingleStringMathTex):
         *tex_strings,
         arg_separator: str = " ",
         substrings_to_isolate: Iterable[str] | None = None,
-        tex_to_color_map: dict[str, Color] = None,
+        tex_to_color_map: dict[str, ManimColor] = None,
         tex_environment: str = "align*",
         **kwargs,
     ):
@@ -346,10 +344,6 @@ class MathTex(SingleStringMathTex):
                 curr_index + num_submobs + len("".join(self.arg_separator.split()))
             )
             if num_submobs == 0:
-                # For cases like empty tex_strings, we want the corresponding
-                # part of the whole MathTex to be a VectorizedPoint
-                # positioned in the right part of the MathTex
-                sub_tex_mob.submobjects = [VectorizedPoint()]
                 last_submob_index = min(curr_index, len(self.submobjects) - 1)
                 sub_tex_mob.move_to(self.submobjects[last_submob_index], RIGHT)
             else:
@@ -455,7 +449,8 @@ class Tex(MathTex):
 
 
 class BulletedList(Tex):
-    """
+    """A bulleted list.
+
     Examples
     --------
 
@@ -508,7 +503,8 @@ class BulletedList(Tex):
 
 
 class Title(Tex):
-    """
+    """A mobject representing an underlined title.
+
     Examples
     --------
     .. manim:: TitleExample

manim/mobject/text/text_mobject.py

@@ -63,7 +63,6 @@ from typing import Iterable, Sequence
 
 import manimpango
 import numpy as np
-from colour import Color
 from manimpango import MarkupUtils, PangoUtils, TextSetting
 
 from manim import config, logger
@@ -71,7 +70,7 @@ from manim.constants import *
 from manim.mobject.geometry.arc import Dot
 from manim.mobject.svg.svg_mobject import SVGMobject
 from manim.mobject.types.vectorized_mobject import VGroup, VMobject
-from manim.utils.color import Colors, color_gradient
+from manim.utils.color import ManimColor, ParsableManimColor, color_gradient
 from manim.utils.deprecation import deprecated
 
 TEXT_MOB_SCALE_FACTOR = 0.05
@@ -148,7 +147,7 @@ class Paragraph(VGroup):
         self,
         *text: Sequence[str],
         line_spacing: float = -1,
-        alignment: Optional[str] = None,
+        alignment: str | None = None,
         **kwargs,
     ) -> None:
         self.line_spacing = line_spacing
@@ -413,7 +412,7 @@ class Text(SVGMobject):
         text: str,
         fill_opacity: float = 1.0,
         stroke_width: float = 0,
-        color: Color | str | None = None,
+        color: ParsableManimColor | None = None,
         font_size: float = DEFAULT_FONT_SIZE,
         line_spacing: float = -1,
         font: str = "",
@@ -463,7 +462,7 @@ class Text(SVGMobject):
         t2g = kwargs.pop("text2gradient", t2g)
         t2s = kwargs.pop("text2slant", t2s)
         t2w = kwargs.pop("text2weight", t2w)
-        self.t2c = t2c
+        self.t2c = {k: ManimColor(v).to_hex() for k, v in t2c.items()}
         self.t2f = t2f
         self.t2g = t2g
         self.t2s = t2s
@@ -482,8 +481,8 @@ class Text(SVGMobject):
         else:
             self.line_spacing = self._font_size + self._font_size * self.line_spacing
 
-        color = Color(color) if color else VMobject().color
-        file_name = self._text2svg(color)
+        color: ManimColor = ManimColor(color) if color else VMobject().color
+        file_name = self._text2svg(color.to_hex())
         PangoUtils.remove_last_M(file_name)
         super().__init__(
             file_name,
@@ -643,10 +642,10 @@ class Text(SVGMobject):
             for start, end in self._find_indexes(word, self.text):
                 self.chars[start:end].set_color_by_gradient(*gradient)
 
-    def _text2hash(self, color: Color):
+    def _text2hash(self, color: ManimColor):
         """Generates ``sha256`` hash for file name."""
         settings = (
-            "PANGO" + self.font + self.slant + self.weight + color.hex_l
+            "PANGO" + self.font + self.slant + self.weight + str(color)
         )  # to differentiate Text and CairoText
         settings += str(self.t2f) + str(self.t2s) + str(self.t2w) + str(self.t2c)
         settings += str(self.line_spacing) + str(self._font_size)
@@ -691,7 +690,9 @@ class Text(SVGMobject):
         t2xwords = set(chain(*([*t2x.keys()] for t2x, _ in t2xs)))
         for word in t2xwords:
             setting_args = {
-                arg: t2x[word] if word in t2x else default_args[arg]
+                arg: str(t2x[word]) if word in t2x else default_args[arg]
+                # NOTE: when t2x[word] is a ManimColor, str will yield the
+                # hex representation
                 for t2x, arg in t2xs
             }
 
@@ -707,13 +708,13 @@ class Text(SVGMobject):
         if self.gradient:
             colors = color_gradient(self.gradient, len(self.text))
             for i in range(len(self.text)):
-                args["color"] = colors[i].hex
+                args["color"] = colors[i].to_hex()
                 settings.append(TextSetting(i, i + 1, **args))
 
         for word, gradient in self.t2g.items():
             if isinstance(gradient, str) or len(gradient) == 1:
                 color = gradient if isinstance(gradient, str) else gradient[0]
-                gradient = [Color(color)]
+                gradient = [ManimColor(color)]
             colors = (
                 color_gradient(gradient, len(word))
                 if len(gradient) != 1
@@ -721,11 +722,11 @@ class Text(SVGMobject):
             )
             for start, end in self._find_indexes(word, self.text):
                 for i in range(start, end):
-                    args["color"] = colors[i - start].hex
+                    args["color"] = colors[i - start].to_hex()
                     settings.append(TextSetting(i, i + 1, **args))
         return settings
 
-    def _text2settings(self, color: Color):
+    def _text2settings(self, color: str):
         """Converts the texts and styles to a setting for parsing."""
         t2xs = [
             (self.t2f, "font"),
@@ -734,8 +735,9 @@ class Text(SVGMobject):
             (self.t2c, "color"),
         ]
         # setting_args requires values to be strings
+
         default_args = {
-            arg: getattr(self, arg) if arg != "color" else str(color) for _, arg in t2xs
+            arg: getattr(self, arg) if arg != "color" else color for _, arg in t2xs
         }
 
         settings = self._get_settings_from_t2xs(t2xs, default_args)
@@ -791,7 +793,7 @@ class Text(SVGMobject):
 
         return settings
 
-    def _text2svg(self, color: Color):
+    def _text2svg(self, color: ManimColor):
         """Convert the text to SVG using Pango."""
         size = self._font_size
         line_spacing = self.line_spacing
@@ -1136,7 +1138,7 @@ class MarkupText(SVGMobject):
         text: str,
         fill_opacity: float = 1,
         stroke_width: float = 0,
-        color: Color | None = None,
+        color: ParsableManimColor | None = None,
         font_size: float = DEFAULT_FONT_SIZE,
         line_spacing: int = -1,
         font: str = "",
@@ -1189,7 +1191,7 @@ class MarkupText(SVGMobject):
         else:
             self.line_spacing = self._font_size + self._font_size * self.line_spacing
 
-        color = Color(color) if color else VMobject().color
+        color: ManimColor = ManimColor(color) if color else VMobject().color
         file_name = self._text2svg(color)
 
         PangoUtils.remove_last_M(file_name)
@@ -1305,10 +1307,14 @@ class MarkupText(SVGMobject):
         else:
             self.scale(font_val / self.font_size)
 
-    def _text2hash(self, color: Color):
+    def _text2hash(self, color: ParsableManimColor):
         """Generates ``sha256`` hash for file name."""
         settings = (
-            "MARKUPPANGO" + self.font + self.slant + self.weight + color.hex_l
+            "MARKUPPANGO"
+            + self.font
+            + self.slant
+            + self.weight
+            + ManimColor(color).to_hex().lower()
         )  # to differentiate from classical Pango Text
         settings += str(self.line_spacing) + str(self._font_size)
         settings += str(self.disable_ligatures)
@@ -1318,23 +1324,25 @@ class MarkupText(SVGMobject):
         hasher.update(id_str.encode())
         return hasher.hexdigest()[:16]
 
-    def _text2svg(self, color: Color | None):
+    def _text2svg(self, color: ParsableManimColor | None):
         """Convert the text to SVG using Pango."""
+        color = ManimColor(color)
         size = self._font_size
         line_spacing = self.line_spacing
         size /= TEXT2SVG_ADJUSTMENT_FACTOR
         line_spacing /= TEXT2SVG_ADJUSTMENT_FACTOR
 
         dir_name = config.get_dir("text_dir")
-        if not dir_name.exists():
+        if not dir_name.is_dir():
             dir_name.mkdir(parents=True)
         hash_name = self._text2hash(color)
         file_name = dir_name / (hash_name + ".svg")
+
         if file_name.exists():
             svg_file = str(file_name.resolve())
         else:
             final_text = (
-                f'<span foreground="{color}">{self.text}</span>'
+                f'<span foreground="{color.to_hex()}">{self.text}</span>'
                 if color is not None
                 else self.text
             )
@@ -1412,7 +1420,7 @@ class MarkupText(SVGMobject):
         if re.match("#[0-9a-f]{6}", col):
             return col
         else:
-            return Colors[col.lower()].value
+            return ManimColor(col).to_hex()
 
     def _extract_color_tags(self):
         """Used to determine which parts (if any) of the string should be formatted

manim/mobject/three_d/three_d_utils.py

@@ -14,40 +14,45 @@ __all__ = [
 ]
 
 
+from typing import TYPE_CHECKING, Literal
+
 import numpy as np
 
 from manim.constants import ORIGIN, UP
 from manim.utils.space_ops import get_unit_normal
 
+if TYPE_CHECKING:
+    from manim.typing import Point3D, Vector
+
 
-def get_3d_vmob_gradient_start_and_end_points(vmob):
+def get_3d_vmob_gradient_start_and_end_points(vmob) -> tuple[Point3D, Point3D]:
     return (
         get_3d_vmob_start_corner(vmob),
         get_3d_vmob_end_corner(vmob),
     )
 
 
-def get_3d_vmob_start_corner_index(vmob):
+def get_3d_vmob_start_corner_index(vmob) -> Literal[0]:
     return 0
 
 
-def get_3d_vmob_end_corner_index(vmob):
+def get_3d_vmob_end_corner_index(vmob) -> int:
     return ((len(vmob.points) - 1) // 6) * 3
 
 
-def get_3d_vmob_start_corner(vmob):
+def get_3d_vmob_start_corner(vmob) -> Point3D:
     if vmob.get_num_points() == 0:
         return np.array(ORIGIN)
     return vmob.points[get_3d_vmob_start_corner_index(vmob)]
 
 
-def get_3d_vmob_end_corner(vmob):
+def get_3d_vmob_end_corner(vmob) -> Point3D:
     if vmob.get_num_points() == 0:
         return np.array(ORIGIN)
     return vmob.points[get_3d_vmob_end_corner_index(vmob)]
 
 
-def get_3d_vmob_unit_normal(vmob, point_index):
+def get_3d_vmob_unit_normal(vmob, point_index: int) -> Vector:
     n_points = vmob.get_num_points()
     if len(vmob.get_anchors()) <= 2:
         return np.array(UP)
@@ -63,9 +68,9 @@ def get_3d_vmob_unit_normal(vmob, point_index):
     return unit_normal
 
 
-def get_3d_vmob_start_corner_unit_normal(vmob):
+def get_3d_vmob_start_corner_unit_normal(vmob) -> Vector:
     return get_3d_vmob_unit_normal(vmob, get_3d_vmob_start_corner_index(vmob))
 
 
-def get_3d_vmob_end_corner_unit_normal(vmob):
+def get_3d_vmob_end_corner_unit_normal(vmob) -> Vector:
     return get_3d_vmob_unit_normal(vmob, get_3d_vmob_end_corner_index(vmob))

manim/mobject/three_d/three_dimensions.py

@@ -2,6 +2,9 @@
 
 from __future__ import annotations
 
+from manim.typing import Point3D, Vector3
+from manim.utils.color import BLUE, BLUE_D, BLUE_E, LIGHT_GREY, WHITE, interpolate_color
+
 __all__ = [
     "ThreeDVMobject",
     "Surface",
@@ -16,9 +19,10 @@ __all__ = [
     "Torus",
 ]
 
-from typing import TYPE_CHECKING
+from typing import Any, Callable, Iterable, Sequence
 
 import numpy as np
+from typing_extensions import Self
 
 from manim import config, logger
 from manim.constants import *
@@ -28,15 +32,19 @@ from manim.mobject.mobject import *
 from manim.mobject.opengl.opengl_compatibility import ConvertToOpenGL
 from manim.mobject.opengl.opengl_mobject import OpenGLMobject
 from manim.mobject.types.vectorized_mobject import VGroup, VMobject
-from manim.utils.color import *
+from manim.utils.color import (
+    BLUE,
+    BLUE_D,
+    BLUE_E,
+    LIGHT_GREY,
+    WHITE,
+    ManimColor,
+    ParsableManimColor,
+    interpolate_color,
+)
 from manim.utils.iterables import tuplify
 from manim.utils.space_ops import normalize, perpendicular_bisector, z_to_vector
 
-if TYPE_CHECKING:
-    from typing import *
-
-    from colour import Color
-
 
 class ThreeDVMobject(VMobject, metaclass=ConvertToOpenGL):
     def __init__(self, shade_in_3d: bool = True, **kwargs):
@@ -102,24 +110,29 @@ class Surface(VGroup, metaclass=ConvertToOpenGL):
         v_range: Sequence[float] = [0, 1],
         resolution: Sequence[int] = 32,
         surface_piece_config: dict = {},
-        fill_color: Color = BLUE_D,
+        fill_color: ParsableManimColor = BLUE_D,
         fill_opacity: float = 1.0,
-        checkerboard_colors: Sequence[Color] = [BLUE_D, BLUE_E],
-        stroke_color: Color = LIGHT_GREY,
+        checkerboard_colors: Sequence[ParsableManimColor] | bool = [BLUE_D, BLUE_E],
+        stroke_color: ParsableManimColor = LIGHT_GREY,
         stroke_width: float = 0.5,
         should_make_jagged: bool = False,
         pre_function_handle_to_anchor_scale_factor: float = 0.00001,
-        **kwargs,
+        **kwargs: Any,
     ) -> None:
         self.u_range = u_range
         self.v_range = v_range
         super().__init__(**kwargs)
         self.resolution = resolution
         self.surface_piece_config = surface_piece_config
-        self.fill_color = fill_color
+        self.fill_color: ManimColor = ManimColor(fill_color)
         self.fill_opacity = fill_opacity
-        self.checkerboard_colors = checkerboard_colors
-        self.stroke_color = stroke_color
+        if checkerboard_colors:
+            self.checkerboard_colors: list[ManimColor] = [
+                ManimColor(x) for x in checkerboard_colors
+            ]
+        else:
+            self.checkerboard_colors = checkerboard_colors
+        self.stroke_color: ManimColor = ManimColor(stroke_color)
         self.stroke_width = stroke_width
         self.should_make_jagged = should_make_jagged
         self.pre_function_handle_to_anchor_scale_factor = (
@@ -132,16 +145,9 @@ class Surface(VGroup, metaclass=ConvertToOpenGL):
             self.make_jagged()
 
     def func(self, u: float, v: float) -> np.ndarray:
-        """The z values defining the :class:`Surface` being plotted.
-
-        Returns
-        -------
-        :class:`numpy.array`
-            The z values defining the :class:`Surface`.
-        """
         return self._func(u, v)
 
-    def _get_u_values_and_v_values(self):
+    def _get_u_values_and_v_values(self) -> tuple[np.ndarray, np.ndarray]:
         res = tuplify(self.resolution)
         if len(res) == 1:
             u_res = v_res = res[0]
@@ -153,7 +159,7 @@ class Surface(VGroup, metaclass=ConvertToOpenGL):
 
         return u_values, v_values
 
-    def _setup_in_uv_space(self):
+    def _setup_in_uv_space(self) -> None:
         u_values, v_values = self._get_u_values_and_v_values()
         faces = VGroup()
         for i in range(len(u_values) - 1):
@@ -188,8 +194,8 @@ class Surface(VGroup, metaclass=ConvertToOpenGL):
             self.set_fill_by_checkerboard(*self.checkerboard_colors)
 
     def set_fill_by_checkerboard(
-        self, *colors: Sequence[Color], opacity: float = None
-    ) -> Mobject:
+        self, *colors: Iterable[ParsableManimColor], opacity: float | None = None
+    ) -> Self:
         """Sets the fill_color of each face of :class:`Surface` in
         an alternating pattern.
 
@@ -215,10 +221,10 @@ class Surface(VGroup, metaclass=ConvertToOpenGL):
     def set_fill_by_value(
         self,
         axes: Mobject,
-        colorscale: Union[Iterable[Color], Color] | None = None,
+        colorscale: list[ParsableManimColor] | ParsableManimColor | None = None,
         axis: int = 2,
         **kwargs,
-    ) -> Mobject:
+    ) -> Self:
         """Sets the color of each mobject of a parametric surface to a color
         relative to its axis-value.
 
@@ -372,9 +378,9 @@ class Sphere(Surface):
 
     def __init__(
         self,
-        center: Sequence[float] = ORIGIN,
+        center: Point3D = ORIGIN,
         radius: float = 1,
-        resolution: Sequence[int] = None,
+        resolution: Sequence[int] | None = None,
         u_range: Sequence[float] = (0, TAU),
         v_range: Sequence[float] = (0, PI),
         **kwargs,
@@ -449,8 +455,8 @@ class Dot3D(Sphere):
         self,
         point: list | np.ndarray = ORIGIN,
         radius: float = DEFAULT_DOT_RADIUS,
-        color: Color = WHITE,
-        resolution: Sequence[int] = (8, 8),
+        color: ParsableManimColor = WHITE,
+        resolution: tuple[int, int] = (8, 8),
         **kwargs,
     ) -> None:
         super().__init__(center=point, radius=radius, resolution=resolution, **kwargs)
@@ -491,7 +497,7 @@ class Cube(VGroup):
         self,
         side_length: float = 2,
         fill_opacity: float = 0.75,
-        fill_color: Color = BLUE,
+        fill_color: ParsableManimColor = BLUE,
         stroke_width: float = 0,
         **kwargs,
     ) -> None:
@@ -542,7 +548,9 @@ class Prism(Cube):
                 self.add(prismSmall, prismLarge)
     """
 
-    def __init__(self, dimensions: Sequence[int] = [3, 2, 1], **kwargs) -> None:
+    def __init__(
+        self, dimensions: tuple[float, float, float] | np.ndarray = [3, 2, 1], **kwargs
+    ) -> None:
         self.dimensions = dimensions
         super().__init__(**kwargs)
 
@@ -600,8 +608,8 @@ class Cone(Surface):
         v_range: Sequence[float] = [0, TAU],
         u_min: float = 0,
         checkerboard_colors: bool = False,
-        **kwargs,
-    ):
+        **kwargs: Any,
+    ) -> None:
         self.direction = direction
         self.theta = PI - np.arctan(base_radius / height)
 
@@ -653,7 +661,7 @@ class Cone(Surface):
             ],
         )
 
-    def _rotate_to_direction(self):
+    def _rotate_to_direction(self) -> None:
         x, y, z = self.direction
 
         r = np.sqrt(x**2 + y**2 + z**2)
@@ -812,7 +820,7 @@ class Cylinder(Surface):
         self.base_bottom.shift(self.u_range[0] * IN)
         self.add(self.base_top, self.base_bottom)
 
-    def _rotate_to_direction(self):
+    def _rotate_to_direction(self) -> None:
         x, y, z = self.direction
 
         r = np.sqrt(x**2 + y**2 + z**2)
@@ -901,7 +909,7 @@ class Line3D(Cylinder):
         start: np.ndarray = LEFT,
         end: np.ndarray = RIGHT,
         thickness: float = 0.02,
-        color: Color = None,
+        color: ParsableManimColor | None = None,
         **kwargs,
     ):
         self.thickness = thickness
@@ -943,7 +951,9 @@ class Line3D(Cylinder):
         self.shift((self.start + self.end) / 2)
 
     def pointify(
-        self, mob_or_point: Mobject | float, direction: np.ndarray = None
+        self,
+        mob_or_point: Mobject | Point3D,
+        direction: Vector3 = None,
     ) -> np.ndarray:
         """Gets a point representing the center of the :class:`Mobjects <.Mobject>`.
 
@@ -989,7 +999,11 @@ class Line3D(Cylinder):
 
     @classmethod
     def parallel_to(
-        cls, line: Line3D, point: Sequence[float] = ORIGIN, length: float = 5, **kwargs
+        cls,
+        line: Line3D,
+        point: Vector3 = ORIGIN,
+        length: float = 5,
+        **kwargs,
     ) -> Line3D:
         """Returns a line parallel to another line going through
         a given point.
@@ -1033,7 +1047,11 @@ class Line3D(Cylinder):
 
     @classmethod
     def perpendicular_to(
-        cls, line: Line3D, point: Sequence[float] = ORIGIN, length: float = 5, **kwargs
+        cls,
+        line: Line3D,
+        point: Vector3 = ORIGIN,
+        length: float = 5,
+        **kwargs,
     ) -> Line3D:
         """Returns a line perpendicular to another line going through
         a given point.
@@ -1124,7 +1142,7 @@ class Arrow3D(Line3D):
         thickness: float = 0.02,
         height: float = 0.3,
         base_radius: float = 0.08,
-        color: Color = WHITE,
+        color: ParsableManimColor = WHITE,
         **kwargs,
     ) -> None:
         super().__init__(
@@ -1182,7 +1200,7 @@ class Torus(Surface):
         minor_radius: float = 1,
         u_range: Sequence[float] = (0, TAU),
         v_range: Sequence[float] = (0, TAU),
-        resolution: Sequence[int] = None,
+        resolution: tuple[int, int] | None = None,
         **kwargs,
     ) -> None:
         if config.renderer == RendererType.OPENGL:

manim/mobject/types/image_mobject.py

@@ -6,7 +6,6 @@ __all__ = ["AbstractImageMobject", "ImageMobject", "ImageMobjectFromCamera"]
 
 import pathlib
 
-import colour
 import numpy as np
 from PIL import Image
 from PIL.Image import Resampling
@@ -17,7 +16,7 @@ from ... import config
 from ...constants import *
 from ...mobject.mobject import Mobject
 from ...utils.bezier import interpolate
-from ...utils.color import WHITE, color_to_int_rgb
+from ...utils.color import WHITE, ManimColor, color_to_int_rgb
 from ...utils.images import change_to_rgba_array, get_full_raster_image_path
 
 
@@ -84,14 +83,16 @@ class AbstractImageMobject(Mobject):
                 "Available algorithms: 'bicubic', 'nearest', 'box', 'bilinear', "
                 "'hamming', 'lanczos'.",
             )
+        return self
 
     def reset_points(self):
-        # Corresponding corners of image are fixed to these 3 points
+        """Sets :attr:`points` to be the four image corners."""
         self.points = np.array(
             [
                 UP + LEFT,
                 UP + RIGHT,
                 DOWN + LEFT,
+                DOWN + RIGHT,
             ],
         )
         self.center()
@@ -276,7 +277,7 @@ class ImageMobject(AbstractImageMobject):
 
     def get_style(self):
         return {
-            "fill_color": colour.rgb2hex(self.color.get_rgb()),
+            "fill_color": ManimColor(self.color.get_rgb()).to_hex(),
             "fill_opacity": self.fill_opacity,
         }