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

manim/utils/color/manim_colors.py

@@ -0,0 +1,218 @@
+"""Colors included in the global name space.
+
+These colors form Manim's default color space.
+
+.. manim:: ColorsOverview
+    :save_last_frame:
+    :hide_source:
+
+    import manim.utils.color.manim_colors as Colors
+
+    class ColorsOverview(Scene):
+        def construct(self):
+            def color_group(color):
+                group = VGroup(
+                    *[
+                        Line(ORIGIN, RIGHT * 1.5, stroke_width=35, color=getattr(Colors, name.upper()))
+                        for name in subnames(color)
+                    ]
+                ).arrange_submobjects(buff=0.4, direction=DOWN)
+
+                name = Text(color).scale(0.6).next_to(group, UP, buff=0.3)
+                if any(decender in color for decender in "gjpqy"):
+                    name.shift(DOWN * 0.08)
+                group.add(name)
+                return group
+
+            def subnames(name):
+                return [name + "_" + char for char in "abcde"]
+
+            color_groups = VGroup(
+                *[
+                    color_group(color)
+                    for color in [
+                        "blue",
+                        "teal",
+                        "green",
+                        "yellow",
+                        "gold",
+                        "red",
+                        "maroon",
+                        "purple",
+                    ]
+                ]
+            ).arrange_submobjects(buff=0.2, aligned_edge=DOWN)
+
+            for line, char in zip(color_groups[0], "abcde"):
+                color_groups.add(Text(char).scale(0.6).next_to(line, LEFT, buff=0.2))
+
+            def named_lines_group(length, color_names, labels, align_to_block):
+                colors = [getattr(Colors, color.upper()) for color in color_names]
+                lines = VGroup(
+                    *[
+                        Line(
+                            ORIGIN,
+                            RIGHT * length,
+                            stroke_width=55,
+                            color=color,
+                        )
+                        for color in colors
+                    ]
+                ).arrange_submobjects(buff=0.6, direction=DOWN)
+
+                for line, name, color in zip(lines, labels, colors):
+                    line.add(Text(name, color=color.contrasting()).scale(0.6).move_to(line))
+                lines.next_to(color_groups, DOWN, buff=0.5).align_to(
+                    color_groups[align_to_block], LEFT
+                )
+                return lines
+
+            other_colors = (
+                "pink",
+                "light_pink",
+                "orange",
+                "light_brown",
+                "dark_brown",
+                "gray_brown",
+            )
+
+            other_lines = named_lines_group(
+                3.2,
+                other_colors,
+                other_colors,
+                0,
+            )
+
+            gray_lines = named_lines_group(
+                6.6,
+                ["white"] + subnames("gray") + ["black"],
+                [
+                    "white",
+                    "lighter_gray / gray_a",
+                    "light_gray / gray_b",
+                    "gray / gray_c",
+                    "dark_gray / gray_d",
+                    "darker_gray / gray_e",
+                    "black",
+                ],
+                2,
+            )
+
+            pure_colors = (
+                "pure_red",
+                "pure_green",
+                "pure_blue",
+            )
+
+            pure_lines = named_lines_group(
+                3.2,
+                pure_colors,
+                pure_colors,
+                6,
+            )
+
+            self.add(color_groups, other_lines, gray_lines, pure_lines)
+
+            VGroup(*self.mobjects).move_to(ORIGIN)
+
+.. automanimcolormodule:: manim.utils.color.manim_colors
+
+"""
+
+from __future__ import annotations
+
+from .core import ManimColor
+
+WHITE = ManimColor("#FFFFFF")
+GRAY_A = ManimColor("#DDDDDD")
+GREY_A = ManimColor("#DDDDDD")
+GRAY_B = ManimColor("#BBBBBB")
+GREY_B = ManimColor("#BBBBBB")
+GRAY_C = ManimColor("#888888")
+GREY_C = ManimColor("#888888")
+GRAY_D = ManimColor("#444444")
+GREY_D = ManimColor("#444444")
+GRAY_E = ManimColor("#222222")
+GREY_E = ManimColor("#222222")
+BLACK = ManimColor("#000000")
+LIGHTER_GRAY = ManimColor("#DDDDDD")
+LIGHTER_GREY = ManimColor("#DDDDDD")
+LIGHT_GRAY = ManimColor("#BBBBBB")
+LIGHT_GREY = ManimColor("#BBBBBB")
+GRAY = ManimColor("#888888")
+GREY = ManimColor("#888888")
+DARK_GRAY = ManimColor("#444444")
+DARK_GREY = ManimColor("#444444")
+DARKER_GRAY = ManimColor("#222222")
+DARKER_GREY = ManimColor("#222222")
+BLUE_A = ManimColor("#C7E9F1")
+BLUE_B = ManimColor("#9CDCEB")
+BLUE_C = ManimColor("#58C4DD")
+BLUE_D = ManimColor("#29ABCA")
+BLUE_E = ManimColor("#236B8E")
+PURE_BLUE = ManimColor("#0000FF")
+BLUE = ManimColor("#58C4DD")
+DARK_BLUE = ManimColor("#236B8E")
+TEAL_A = ManimColor("#ACEAD7")
+TEAL_B = ManimColor("#76DDC0")
+TEAL_C = ManimColor("#5CD0B3")
+TEAL_D = ManimColor("#55C1A7")
+TEAL_E = ManimColor("#49A88F")
+TEAL = ManimColor("#5CD0B3")
+GREEN_A = ManimColor("#C9E2AE")
+GREEN_B = ManimColor("#A6CF8C")
+GREEN_C = ManimColor("#83C167")
+GREEN_D = ManimColor("#77B05D")
+GREEN_E = ManimColor("#699C52")
+PURE_GREEN = ManimColor("#00FF00")
+GREEN = ManimColor("#83C167")
+YELLOW_A = ManimColor("#FFF1B6")
+YELLOW_B = ManimColor("#FFEA94")
+YELLOW_C = ManimColor("#FFFF00")
+YELLOW_D = ManimColor("#F4D345")
+YELLOW_E = ManimColor("#E8C11C")
+YELLOW = ManimColor("#FFFF00")
+GOLD_A = ManimColor("#F7C797")
+GOLD_B = ManimColor("#F9B775")
+GOLD_C = ManimColor("#F0AC5F")
+GOLD_D = ManimColor("#E1A158")
+GOLD_E = ManimColor("#C78D46")
+GOLD = ManimColor("#F0AC5F")
+RED_A = ManimColor("#F7A1A3")
+RED_B = ManimColor("#FF8080")
+RED_C = ManimColor("#FC6255")
+RED_D = ManimColor("#E65A4C")
+RED_E = ManimColor("#CF5044")
+PURE_RED = ManimColor("#FF0000")
+RED = ManimColor("#FC6255")
+MAROON_A = ManimColor("#ECABC1")
+MAROON_B = ManimColor("#EC92AB")
+MAROON_C = ManimColor("#C55F73")
+MAROON_D = ManimColor("#A24D61")
+MAROON_E = ManimColor("#94424F")
+MAROON = ManimColor("#C55F73")
+PURPLE_A = ManimColor("#CAA3E8")
+PURPLE_B = ManimColor("#B189C6")
+PURPLE_C = ManimColor("#9A72AC")
+PURPLE_D = ManimColor("#715582")
+PURPLE_E = ManimColor("#644172")
+PURPLE = ManimColor("#9A72AC")
+PINK = ManimColor("#D147BD")
+LIGHT_PINK = ManimColor("#DC75CD")
+ORANGE = ManimColor("#FF862F")
+LIGHT_BROWN = ManimColor("#CD853F")
+DARK_BROWN = ManimColor("#8B4513")
+GRAY_BROWN = ManimColor("#736357")
+GREY_BROWN = ManimColor("#736357")
+
+# Colors used for Manim Community's logo and banner
+
+LOGO_WHITE = ManimColor("#ECE7E2")
+LOGO_GREEN = ManimColor("#87C2A5")
+LOGO_BLUE = ManimColor("#525893")
+LOGO_RED = ManimColor("#E07A5F")
+LOGO_BLACK = ManimColor("#343434")
+
+_all_manim_colors: list[ManimColor] = [
+    x for x in globals().values() if isinstance(x, ManimColor)
+]

manim/utils/commands.py

@@ -1,10 +1,14 @@
 from __future__ import annotations
 
-import json
 import os
+from collections.abc import Generator
 from pathlib import Path
 from subprocess import run
-from typing import Generator
+from typing import TypedDict
+
+import av
+
+from manim.typing import StrOrBytesPath
 
 __all__ = [
     "capture",
@@ -13,28 +17,52 @@ __all__ = [
 ]
 
 
-def capture(command, cwd=None, command_input=None):
-    p = run(command, cwd=cwd, input=command_input, capture_output=True, text=True)
+def capture(
+    command: str, cwd: StrOrBytesPath | None = None, command_input: str | None = None
+) -> tuple[str, str, int]:
+    p = run(
+        command,
+        cwd=cwd,
+        input=command_input,
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+    )
     out, err = p.stdout, p.stderr
     return out, err, p.returncode
 
 
-def get_video_metadata(path_to_video: str | os.PathLike) -> dict[str]:
-    command = [
-        "ffprobe",
-        "-v",
-        "error",
-        "-select_streams",
-        "v:0",
-        "-show_entries",
-        "stream=width,height,nb_frames,duration,avg_frame_rate,codec_name",
-        "-print_format",
-        "json",
-        str(path_to_video),
-    ]
-    config, err, exitcode = capture(command)
-    assert exitcode == 0, f"FFprobe error: {err}"
-    return json.loads(config)["streams"][0]
+class VideoMetadata(TypedDict):
+    width: int
+    height: int
+    nb_frames: str
+    duration: str
+    avg_frame_rate: str
+    codec_name: str
+    pix_fmt: str
+
+
+def get_video_metadata(path_to_video: str | os.PathLike) -> VideoMetadata:
+    with av.open(str(path_to_video)) as container:
+        stream = container.streams.video[0]
+        ctxt = stream.codec_context
+        rate = stream.average_rate
+        if stream.duration is not None:
+            duration = float(stream.duration * stream.time_base)
+            num_frames = stream.frames
+        else:
+            num_frames = sum(1 for _ in container.decode(video=0))
+            duration = float(num_frames / stream.base_rate)
+
+        return {
+            "width": ctxt.width,
+            "height": ctxt.height,
+            "nb_frames": str(num_frames),
+            "duration": f"{duration:.6f}",
+            "avg_frame_rate": f"{rate.numerator}/{rate.denominator}",  # Can be a Fraction
+            "codec_name": stream.codec_context.name,
+            "pix_fmt": stream.codec_context.pix_fmt,
+        }
 
 
 def get_dir_layout(dirpath: Path) -> Generator[str, None, None]:

manim/utils/config_ops.py

@@ -10,11 +10,13 @@ __all__ = [
 
 
 import itertools as it
+from typing import Any, Generic, Protocol, cast
 
-import numpy as np
+import numpy.typing as npt
+from typing_extensions import TypeVar
 
 
-def merge_dicts_recursively(*dicts):
+def merge_dicts_recursively(*dicts: dict[Any, Any]) -> dict[Any, Any]:
     """
     Creates a dict whose keyset is the union of all the
     input dictionaries.  The value for each key is based
@@ -24,7 +26,7 @@ def merge_dicts_recursively(*dicts):
 
     When values are dictionaries, it is applied recursively
     """
-    result = {}
+    result: dict = {}
     all_items = it.chain(*(d.items() for d in dicts))
     for key, value in all_items:
         if key in result and isinstance(result[key], dict) and isinstance(value, dict):
@@ -34,7 +36,9 @@ def merge_dicts_recursively(*dicts):
     return result
 
 
-def update_dict_recursively(current_dict, *others):
+def update_dict_recursively(
+    current_dict: dict[Any, Any], *others: dict[Any, Any]
+) -> None:
     updated_dict = merge_dicts_recursively(current_dict, *others)
     current_dict.update(updated_dict)
 
@@ -44,35 +48,51 @@ def update_dict_recursively(current_dict, *others):
 
 
 class DictAsObject:
-    def __init__(self, dictin):
+    def __init__(self, dictin: dict[str, Any]):
         self.__dict__ = dictin
 
 
-class _Data:
+_Data_T = TypeVar("_Data_T", bound="npt.NDArray[Any]", default="npt.NDArray[Any]")
+
+
+class _HasData(Protocol):
+    data: dict[str, npt.NDArray[Any]]
+
+
+class _Data(Generic[_Data_T]):
     """Descriptor that allows _Data variables to be grouped and accessed from self.data["attr"] via self.attr.
     self.data attributes must be arrays.
     """
 
-    def __set_name__(self, obj, name):
-        self.name = name
+    def __set_name__(self, obj: _HasData, name: str) -> None:
+        self.name: str = name
 
-    def __get__(self, obj, owner):
-        return obj.data[self.name]
+    def __get__(self, obj: _HasData, owner: Any) -> _Data_T:
+        value = cast(_Data_T, obj.data[self.name])
+        return value
 
-    def __set__(self, obj, array: np.ndarray):
+    def __set__(self, obj: _HasData, array: _Data_T) -> None:
         obj.data[self.name] = array
 
 
-class _Uniforms:
+_Uniforms_T = TypeVar("_Uniforms_T", bound="float | tuple[float, ...]", default=float)
+
+
+class _HasUniforms(Protocol):
+    uniforms: dict[str, float | tuple[float, ...]]
+
+
+class _Uniforms(Generic[_Uniforms_T]):
     """Descriptor that allows _Uniforms variables to be grouped from self.uniforms["attr"] via self.attr.
-    self.uniforms attributes must be floats.
+    self.uniforms attributes must be floats or tuples of floats.
     """
 
-    def __set_name__(self, obj, name):
-        self.name = name
+    def __set_name__(self, obj: _HasUniforms, name: str) -> None:
+        self.name: str = name
 
-    def __get__(self, obj, owner):
-        return obj.__dict__["uniforms"][self.name]
+    def __get__(self, obj: _HasUniforms, owner: Any) -> _Uniforms_T:
+        val = cast(_Uniforms_T, obj.uniforms[self.name])
+        return val
 
-    def __set__(self, obj, num: float):
-        obj.__dict__["uniforms"][self.name] = num
+    def __set__(self, obj: _HasUniforms, num: _Uniforms_T) -> None:
+        obj.uniforms[self.name] = num

manim/utils/debug.py

@@ -1,19 +1,21 @@
 """Debugging utilities."""
 
-
 from __future__ import annotations
 
 __all__ = ["print_family", "index_labels"]
 
 
+from typing import Any
+
 from manim.mobject.mobject import Mobject
 from manim.mobject.text.numbers import Integer
+from manim.utils.color import ManimColor
 
 from ..mobject.types.vectorized_mobject import VGroup
 from .color import BLACK
 
 
-def print_family(mobject, n_tabs=0):
+def print_family(mobject: Mobject, n_tabs: int = 0) -> None:
     """For debugging purposes"""
     print("\t" * n_tabs, mobject, id(mobject))
     for submob in mobject.submobjects:
@@ -23,10 +25,10 @@ def print_family(mobject, n_tabs=0):
 def index_labels(
     mobject: Mobject,
     label_height: float = 0.15,
-    background_stroke_width=5,
-    background_stroke_color=BLACK,
-    **kwargs,
-):
+    background_stroke_width: float = 5,
+    background_stroke_color: ManimColor = BLACK,
+    **kwargs: Any,
+) -> VGroup:
     r"""Returns a :class:`~.VGroup` of :class:`~.Integer` mobjects
     that shows the index of each submobject.
 
@@ -68,7 +70,6 @@ def index_labels(
 
                 self.add(text, indices)
     """
-
     labels = VGroup()
     for n, submob in enumerate(mobject):
         label = Integer(n, **kwargs)