manim 0.18.1__py3-none-any.whl → 0.19.0__py3-none-any.whl

manim/utils/color/manim_colors.py

@@ -46,21 +46,22 @@ These colors form Manim's default color space.
             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, colors, names, text_colors, align_to_block):
+            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=getattr(Colors, color.upper()),
+                            color=color,
                         )
                         for color in colors
                     ]
                 ).arrange_submobjects(buff=0.6, direction=DOWN)
 
-                for line, name, color in zip(lines, names, text_colors):
-                    line.add(Text(name, color=color).scale(0.6).move_to(line))
+                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
                 )
@@ -79,7 +80,6 @@ These colors form Manim's default color space.
                 3.2,
                 other_colors,
                 other_colors,
-                [BLACK] * 4 + [WHITE] * 2,
                 0,
             )
 
@@ -95,7 +95,6 @@ These colors form Manim's default color space.
                     "darker_gray / gray_e",
                     "black",
                 ],
-                [BLACK] * 3 + [WHITE] * 4,
                 2,
             )
 
@@ -109,7 +108,6 @@ These colors form Manim's default color space.
                 3.2,
                 pure_colors,
                 pure_colors,
-                [BLACK, BLACK, WHITE],
                 6,
             )
 
@@ -121,7 +119,7 @@ These colors form Manim's default color space.
 
 """
 
-from typing import List
+from __future__ import annotations
 
 from .core import ManimColor
 
@@ -215,6 +213,6 @@ LOGO_BLUE = ManimColor("#525893")
 LOGO_RED = ManimColor("#E07A5F")
 LOGO_BLACK = ManimColor("#343434")
 
-_all_manim_colors: List[ManimColor] = [
+_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,7 +17,9 @@ __all__ = [
 ]
 
 
-def capture(command, cwd=None, command_input=None):
+def capture(
+    command: str, cwd: StrOrBytesPath | None = None, command_input: str | None = None
+) -> tuple[str, str, int]:
     p = run(
         command,
         cwd=cwd,
@@ -26,22 +32,37 @@ def capture(command, cwd=None, command_input=None):
     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,12 @@ __all__ = [
 
 
 import itertools as it
+from typing import Any
 
-import numpy as np
+import numpy.typing as npt
 
 
-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 +25,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 +35,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,7 +47,7 @@ def update_dict_recursively(current_dict, *others):
 
 
 class DictAsObject:
-    def __init__(self, dictin):
+    def __init__(self, dictin: dict[str, Any]):
         self.__dict__ = dictin
 
 
@@ -53,13 +56,14 @@ class _Data:
     self.data attributes must be arrays.
     """
 
-    def __set_name__(self, obj, name):
+    def __set_name__(self, obj: Any, name: str) -> None:
         self.name = name
 
-    def __get__(self, obj, owner):
-        return obj.data[self.name]
+    def __get__(self, obj: Any, owner: Any) -> npt.NDArray[Any]:
+        value: npt.NDArray[Any] = obj.data[self.name]
+        return value
 
-    def __set__(self, obj, array: np.ndarray):
+    def __set__(self, obj: Any, array: npt.NDArray[Any]) -> None:
         obj.data[self.name] = array
 
 
@@ -68,11 +72,12 @@ class _Uniforms:
     self.uniforms attributes must be floats.
     """
 
-    def __set_name__(self, obj, name):
+    def __set_name__(self, obj: Any, name: str) -> None:
         self.name = name
 
-    def __get__(self, obj, owner):
-        return obj.__dict__["uniforms"][self.name]
+    def __get__(self, obj: Any, owner: Any) -> float:
+        val: float = obj.__dict__["uniforms"][self.name]
+        return val
 
-    def __set__(self, obj, num: float):
+    def __set__(self, obj: Any, num: float) -> None:
         obj.__dict__["uniforms"][self.name] = num

manim/utils/debug.py

@@ -5,14 +5,17 @@ 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:
@@ -22,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.
 
@@ -67,7 +70,6 @@ def index_labels(
 
                 self.add(text, indices)
     """
-
     labels = VGroup()
     for n, submob in enumerate(mobject):
         label = Integer(n, **kwargs)

manim/utils/deprecation.py

@@ -6,15 +6,17 @@ __all__ = ["deprecated", "deprecated_params"]
 
 
 import inspect
+import logging
 import re
-from typing import Any, Callable, Iterable
+from collections.abc import Iterable
+from typing import Any, Callable, TypeVar, overload
 
 from decorator import decorate, decorator
 
-from .. import logger
+logger = logging.getLogger("manim")
 
 
-def _get_callable_info(callable: Callable) -> tuple[str, str]:
+def _get_callable_info(callable_: Callable[..., Any], /) -> tuple[str, str]:
     """Returns type and name of a callable.
 
     Parameters
@@ -28,8 +30,8 @@ def _get_callable_info(callable: Callable) -> tuple[str, str]:
         The type and name of the callable. Type can can be one of "class", "method" (for
         functions defined in classes) or "function"). For methods, name is Class.method.
     """
-    what = type(callable).__name__
-    name = callable.__qualname__
+    what = type(callable_).__name__
+    name = callable_.__qualname__
     if what == "function" and "." in name:
         what = "method"
     elif what != "function":
@@ -38,9 +40,9 @@ def _get_callable_info(callable: Callable) -> tuple[str, str]:
 
 
 def _deprecation_text_component(
-    since: str | None,
-    until: str | None,
-    message: str,
+    since: str | None = None,
+    until: str | None = None,
+    message: str | None = None,
 ) -> str:
     """Generates a text component used in deprecation messages.
 
@@ -68,13 +70,37 @@ def _deprecation_text_component(
     return f"deprecated {since}and {until}.{msg}"
 
 
+# TODO: Use ParamSpec to type decorated functions when Python 3.9 is out of life
+T = TypeVar("T")
+
+
+@overload
+def deprecated(
+    func: Callable[..., T],
+    since: str | None = None,
+    until: str | None = None,
+    replacement: str | None = None,
+    message: str | None = "",
+) -> Callable[..., T]: ...
+
+
+@overload
+def deprecated(
+    func: None = None,
+    since: str | None = None,
+    until: str | None = None,
+    replacement: str | None = None,
+    message: str | None = "",
+) -> Callable[[Callable[..., T]], Callable[..., T]]: ...
+
+
 def deprecated(
-    func: Callable = None,
+    func: Callable[..., T] | None = None,
     since: str | None = None,
     until: str | None = None,
     replacement: str | None = None,
     message: str | None = "",
-) -> Callable:
+) -> Callable[..., T] | Callable[[Callable[..., T]], Callable[..., T]]:
     """Decorator to mark a callable as deprecated.
 
     The decorated callable will cause a warning when used. The docstring of the
@@ -104,10 +130,12 @@ def deprecated(
 
         from manim.utils.deprecation import deprecated
 
+
         @deprecated
         def foo(**kwargs):
             pass
 
+
         @deprecated
         class Bar:
             def __init__(self):
@@ -117,6 +145,7 @@ def deprecated(
             def baz(self):
                 pass
 
+
         foo()
         # WARNING  The function foo has been deprecated and may be removed in a later version.
 
@@ -130,15 +159,14 @@ def deprecated(
 
         from manim.utils.deprecation import deprecated
 
+
         @deprecated(
-            since="v0.2",
-            until="v0.4",
-            replacement="bar",
-            message="It is cooler."
+            since="v0.2", until="v0.4", replacement="bar", message="It is cooler."
         )
         def foo():
             pass
 
+
         foo()
         # WARNING  The function foo has been deprecated since v0.2 and is expected to be removed after v0.4. Use bar instead. It is cooler.
 
@@ -146,10 +174,12 @@ def deprecated(
 
         from manim.utils.deprecation import deprecated
 
+
         @deprecated(since="05/01/2021", until="06/01/2021")
         def foo():
             pass
 
+
         foo()
         # WARNING  The function foo has been deprecated since 05/01/2021 and is expected to be removed after 06/01/2021.
 
@@ -183,7 +213,7 @@ def deprecated(
         deprecated = _deprecation_text_component(since, until, msg)
         return f"The {what} {name} has been {deprecated}"
 
-    def deprecate_docs(func: Callable):
+    def deprecate_docs(func: Callable) -> None:
         """Adjust docstring to indicate the deprecation.
 
         Parameters
@@ -195,7 +225,7 @@ def deprecated(
         doc_string = func.__doc__ or ""
         func.__doc__ = f"{doc_string}\n\n.. attention:: Deprecated\n  {warning}"
 
-    def deprecate(func: Callable, *args, **kwargs):
+    def deprecate(func: Callable[..., T], *args: Any, **kwargs: Any) -> T:
         """The actual decorator used to extend the callables behavior.
 
         Logs a warning message.
@@ -220,7 +250,10 @@ def deprecated(
 
     if type(func).__name__ != "function":
         deprecate_docs(func)
-        func.__init__ = decorate(func.__init__, deprecate)
+        # The following line raises this mypy error:
+        # Accessing "__init__" on an instance is unsound, since instance.__init__
+        # could be from an incompatible subclass  [misc]</pre>
+        func.__init__ = decorate(func.__init__, deprecate)  # type: ignore[misc]
         return func
 
     func = decorate(func, deprecate)
@@ -232,11 +265,10 @@ def deprecated_params(
     params: str | Iterable[str] | None = None,
     since: str | None = None,
     until: str | None = None,
-    message: str | None = "",
-    redirections: None | (
-        Iterable[tuple[str, str] | Callable[..., dict[str, Any]]]
-    ) = None,
-) -> Callable:
+    message: str = "",
+    redirections: None
+    | (Iterable[tuple[str, str] | Callable[..., dict[str, Any]]]) = None,
+) -> Callable[..., T]:
     """Decorator to mark parameters of a callable as deprecated.
 
     It can also be used to automatically redirect deprecated parameter values to their
@@ -286,10 +318,12 @@ def deprecated_params(
 
         from manim.utils.deprecation import deprecated_params
 
+
         @deprecated_params(params="a, b, c")
         def foo(**kwargs):
             pass
 
+
         foo(x=2, y=3, z=4)
         # No warning
 
@@ -300,15 +334,17 @@ def deprecated_params(
 
         from manim.utils.deprecation import deprecated_params
 
+
         @deprecated_params(
             params="a, b, c",
             since="v0.2",
             until="v0.4",
-            message="The letters x, y, z are cooler."
+            message="The letters x, y, z are cooler.",
         )
         def foo(**kwargs):
             pass
 
+
         foo(a=2)
         # WARNING  The parameter a of method foo has been deprecated since v0.2 and is expected to be removed after v0.4. The letters x, y, z are cooler.
 
@@ -316,14 +352,18 @@ def deprecated_params(
 
         from manim.utils.deprecation import deprecated_params
 
-        @deprecated_params(redirections=[
-            # Two ways to redirect one parameter to another:
-            ("old_param", "new_param"),
-            lambda old_param2: {"new_param22": old_param2}
-        ])
+
+        @deprecated_params(
+            redirections=[
+                # Two ways to redirect one parameter to another:
+                ("old_param", "new_param"),
+                lambda old_param2: {"new_param22": old_param2},
+            ]
+        )
         def foo(**kwargs):
             return kwargs
 
+
         foo(x=1, old_param=2)
         # WARNING  The parameter old_param of method foo has been deprecated and may be removed in a later version.
         # returns {"x": 1, "new_param": 2}
@@ -332,12 +372,14 @@ def deprecated_params(
 
         from manim.utils.deprecation import deprecated_params
 
-        @deprecated_params(redirections=[
-            lambda runtime_in_ms: {"run_time": runtime_in_ms / 1000}
-        ])
+
+        @deprecated_params(
+            redirections=[lambda runtime_in_ms: {"run_time": runtime_in_ms / 1000}]
+        )
         def foo(**kwargs):
             return kwargs
 
+
         foo(runtime_in_ms=500)
         # WARNING  The parameter runtime_in_ms of method foo has been deprecated and may be removed in a later version.
         # returns {"run_time": 0.5}
@@ -346,12 +388,14 @@ def deprecated_params(
 
         from manim.utils.deprecation import deprecated_params
 
-        @deprecated_params(redirections=[
-            lambda buff_x=1, buff_y=1: {"buff": (buff_x, buff_y)}
-        ])
+
+        @deprecated_params(
+            redirections=[lambda buff_x=1, buff_y=1: {"buff": (buff_x, buff_y)}]
+        )
         def foo(**kwargs):
             return kwargs
 
+
         foo(buff_x=2)
         # WARNING  The parameter buff_x of method foo has been deprecated and may be removed in a later version.
         # returns {"buff": (2, 1)}
@@ -360,18 +404,23 @@ def deprecated_params(
 
         from manim.utils.deprecation import deprecated_params
 
-        @deprecated_params(redirections=[
-            lambda buff=1: {"buff_x": buff[0], "buff_y": buff[1]} if isinstance(buff, tuple)
-                    else {"buff_x": buff,    "buff_y": buff}
-        ])
+
+        @deprecated_params(
+            redirections=[
+                lambda buff=1: {"buff_x": buff[0], "buff_y": buff[1]}
+                if isinstance(buff, tuple)
+                else {"buff_x": buff, "buff_y": buff}
+            ]
+        )
         def foo(**kwargs):
             return kwargs
 
+
         foo(buff=0)
         # WARNING  The parameter buff of method foo has been deprecated and may be removed in a later version.
         # returns {"buff_x": 0, buff_y: 0}
 
-        foo(buff=(1,2))
+        foo(buff=(1, 2))
         # WARNING  The parameter buff of method foo has been deprecated and may be removed in a later version.
         # returns {"buff_x": 1, buff_y: 2}
 
@@ -406,7 +455,7 @@ def deprecated_params(
 
     redirections = list(redirections)
 
-    def warning_msg(func: Callable, used: list[str]):
+    def warning_msg(func: Callable[..., T], used: list[str]) -> str:
         """Generate the deprecation warning message.
 
         Parameters
@@ -429,7 +478,7 @@ def deprecated_params(
         deprecated = _deprecation_text_component(since, until, message)
         return f"The parameter{parameter_s} {used_} of {what} {name} {has_have_been} {deprecated}"
 
-    def redirect_params(kwargs: dict, used: list[str]):
+    def redirect_params(kwargs: dict[str, Any], used: list[str]) -> None:
         """Adjust the keyword arguments as defined by the redirections.
 
         Parameters
@@ -453,7 +502,7 @@ def deprecated_params(
                 if len(redirector_args) > 0:
                     kwargs.update(redirector(**redirector_args))
 
-    def deprecate_params(func, *args, **kwargs):
+    def deprecate_params(func: Callable[..., T], *args: Any, **kwargs: Any) -> T:
         """The actual decorator function used to extend the callables behavior.
 
         Logs a warning message when a deprecated parameter is used and redirects it if
@@ -485,4 +534,4 @@ def deprecated_params(
             redirect_params(kwargs, used)
         return func(*args, **kwargs)
 
-    return decorator(deprecate_params)
+    return decorator(deprecate_params)  # type: ignore[return-value]