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

manim/mobject/value_tracker.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 __all__ = ["ValueTracker", "ComplexValueTracker"]
 
+from typing import TYPE_CHECKING, Any
 
 import numpy as np
 
@@ -11,6 +12,11 @@ from manim.mobject.mobject import Mobject
 from manim.mobject.opengl.opengl_compatibility import ConvertToOpenGL
 from manim.utils.paths import straight_path
 
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+    from manim.typing import PathFuncType
+
 
 class ValueTracker(Mobject, metaclass=ConvertToOpenGL):
     """A mobject that can be used for tracking (real-valued) parameters.
@@ -45,7 +51,7 @@ class ValueTracker(Mobject, metaclass=ConvertToOpenGL):
                 self.wait(1)
                 tracker -= 4
                 self.wait(0.5)
-                self.play(tracker.animate.set_value(5)),
+                self.play(tracker.animate.set_value(5))
                 self.wait(0.5)
                 self.play(tracker.animate.set_value(3))
                 self.play(tracker.animate.increment_value(-2))
@@ -69,76 +75,140 @@ class ValueTracker(Mobject, metaclass=ConvertToOpenGL):
 
     """
 
-    def __init__(self, value=0, **kwargs):
+    def __init__(self, value: float = 0, **kwargs: Any) -> None:
         super().__init__(**kwargs)
-        self.set_points(np.zeros((1, 3)))
+        self.set(points=np.zeros((1, 3)))
         self.set_value(value)
 
     def get_value(self) -> float:
         """Get the current value of this ValueTracker."""
-        return self.points[0, 0]
+        value: float = self.points[0, 0]
+        return value
 
-    def set_value(self, value: float):
-        """Sets a new scalar value to the ValueTracker"""
+    def set_value(self, value: float) -> Self:
+        """Sets a new scalar value to the ValueTracker."""
         self.points[0, 0] = value
         return self
 
-    def increment_value(self, d_value: float):
-        """Increments (adds) a scalar value  to the ValueTracker"""
+    def increment_value(self, d_value: float) -> Self:
+        """Increments (adds) a scalar value to the ValueTracker."""
         self.set_value(self.get_value() + d_value)
         return self
 
-    def __bool__(self):
-        """Return whether the value of this value tracker evaluates as true."""
+    def __bool__(self) -> bool:
+        """Return whether the value of this ValueTracker evaluates as true."""
         return bool(self.get_value())
 
-    def __iadd__(self, d_value: float):
-        """adds ``+=`` syntax to increment the value of the ValueTracker"""
+    def __add__(self, d_value: float | Mobject) -> ValueTracker:
+        """Return a new :class:`ValueTracker` whose value is the current tracker's value plus
+        ``d_value``.
+        """
+        if isinstance(d_value, Mobject):
+            raise ValueError(
+                "Cannot increment ValueTracker by a Mobject. Please provide a scalar value."
+            )
+        return ValueTracker(self.get_value() + d_value)
+
+    def __iadd__(self, d_value: float | Mobject) -> Self:
+        """adds ``+=`` syntax to increment the value of the ValueTracker."""
+        if isinstance(d_value, Mobject):
+            raise ValueError(
+                "Cannot increment ValueTracker by a Mobject. Please provide a scalar value."
+            )
         self.increment_value(d_value)
         return self
 
-    def __ifloordiv__(self, d_value: float):
-        """Set the value of this value tracker to the floor division of the current value by ``d_value``."""
+    def __floordiv__(self, d_value: float) -> ValueTracker:
+        """Return a new :class:`ValueTracker` whose value is the floor division of the current
+        tracker's value by ``d_value``.
+        """
+        return ValueTracker(self.get_value() // d_value)
+
+    def __ifloordiv__(self, d_value: float) -> Self:
+        """Set the value of this ValueTracker to the floor division of the current value by ``d_value``."""
         self.set_value(self.get_value() // d_value)
         return self
 
-    def __imod__(self, d_value: float):
-        """Set the value of this value tracker to the current value modulo ``d_value``."""
+    def __mod__(self, d_value: float) -> ValueTracker:
+        """Return a new :class:`ValueTracker` whose value is the current tracker's value
+        modulo ``d_value``.
+        """
+        return ValueTracker(self.get_value() % d_value)
+
+    def __imod__(self, d_value: float) -> Self:
+        """Set the value of this ValueTracker to the current value modulo ``d_value``."""
         self.set_value(self.get_value() % d_value)
         return self
 
-    def __imul__(self, d_value: float):
-        """Set the value of this value tracker to the product of the current value and ``d_value``."""
+    def __mul__(self, d_value: float) -> ValueTracker:
+        """Return a new :class:`ValueTracker` whose value is the current tracker's value multiplied by
+        ``d_value``.
+        """
+        return ValueTracker(self.get_value() * d_value)
+
+    def __imul__(self, d_value: float) -> Self:
+        """Set the value of this ValueTracker to the product of the current value and ``d_value``."""
         self.set_value(self.get_value() * d_value)
         return self
 
-    def __ipow__(self, d_value: float):
-        """Set the value of this value tracker to the current value raised to the power of ``d_value``."""
+    def __pow__(self, d_value: float) -> ValueTracker:
+        """Return a new :class:`ValueTracker` whose value is the current tracker's value raised to the
+        power of ``d_value``.
+        """
+        return ValueTracker(self.get_value() ** d_value)
+
+    def __ipow__(self, d_value: float) -> Self:
+        """Set the value of this ValueTracker to the current value raised to the power of ``d_value``."""
         self.set_value(self.get_value() ** d_value)
         return self
 
-    def __isub__(self, d_value: float):
-        """adds ``-=`` syntax to decrement the value of the ValueTracker"""
+    def __sub__(self, d_value: float | Mobject) -> ValueTracker:
+        """Return a new :class:`ValueTracker` whose value is the current tracker's value minus
+        ``d_value``.
+        """
+        if isinstance(d_value, Mobject):
+            raise ValueError(
+                "Cannot decrement ValueTracker by a Mobject. Please provide a scalar value."
+            )
+        return ValueTracker(self.get_value() - d_value)
+
+    def __isub__(self, d_value: float | Mobject) -> Self:
+        """Adds ``-=`` syntax to decrement the value of the ValueTracker."""
+        if isinstance(d_value, Mobject):
+            raise ValueError(
+                "Cannot decrement ValueTracker by a Mobject. Please provide a scalar value."
+            )
         self.increment_value(-d_value)
         return self
 
-    def __itruediv__(self, d_value: float):
-        """Sets the value of this value tracker to the current value divided by ``d_value``."""
+    def __truediv__(self, d_value: float) -> ValueTracker:
+        """Return a new :class:`ValueTracker` whose value is the current tracker's value
+        divided by ``d_value``.
+        """
+        return ValueTracker(self.get_value() / d_value)
+
+    def __itruediv__(self, d_value: float) -> Self:
+        """Sets the value of this ValueTracker to the current value divided by ``d_value``."""
         self.set_value(self.get_value() / d_value)
         return self
 
-    def interpolate(self, mobject1, mobject2, alpha, path_func=straight_path()):
-        """
-        Turns self into an interpolation between mobject1
-        and mobject2.
-        """
-        self.set_points(path_func(mobject1.points, mobject2.points, alpha))
+    def interpolate(
+        self,
+        mobject1: Mobject,
+        mobject2: Mobject,
+        alpha: float,
+        path_func: PathFuncType = straight_path(),
+    ) -> Self:
+        """Turns ``self`` into an interpolation between ``mobject1`` and ``mobject2``."""
+        self.set(points=path_func(mobject1.points, mobject2.points, alpha))
         return self
 
 
 class ComplexValueTracker(ValueTracker):
     """Tracks a complex-valued parameter.
 
+    The value is internally stored as a points array [a, b, 0]. This can be accessed directly
+    to represent the value geometrically, see the usage example.
     When the value is set through :attr:`animate`, the value will take a straight path from the
     source point to the destination point.
 
@@ -161,15 +231,12 @@ class ComplexValueTracker(ValueTracker):
                 self.play(tracker.animate.set_value(tracker.get_value() / (-2 + 3j)))
     """
 
-    def get_value(self):
-        """Get the current value of this value tracker as a complex number.
-
-        The value is internally stored as a points array [a, b, 0]. This can be accessed directly
-        to represent the value geometrically, see the usage example."""
+    def get_value(self) -> complex:  # type: ignore [override]
+        """Get the current value of this ComplexValueTracker as a complex number."""
         return complex(*self.points[0, :2])
 
-    def set_value(self, z):
-        """Sets a new complex value to the ComplexValueTracker"""
-        z = complex(z)
+    def set_value(self, value: complex | float) -> Self:
+        """Sets a new complex value to the ComplexValueTracker."""
+        z = complex(value)
         self.points[0, :2] = (z.real, z.imag)
         return self

manim/mobject/vector_field.py

@@ -10,11 +10,11 @@ __all__ = [
 
 import itertools as it
 import random
+from collections.abc import Callable, Iterable, Sequence
 from math import ceil, floor
-from typing import Callable, Iterable, Sequence
+from typing import TYPE_CHECKING
 
 import numpy as np
-from colour import Color
 from PIL import Image
 
 from manim.animation.updaters.update import UpdateFromAlphaFunc
@@ -30,10 +30,28 @@ 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
 
+if TYPE_CHECKING:
+    from manim.typing import (
+        FloatRGB,
+        FloatRGB_Array,
+        FloatRGBA_Array,
+        Point3D,
+        Vector3D,
+    )
+
 DEFAULT_SCALAR_FIELD_COLORS: list = [BLUE_E, GREEN, YELLOW, RED]
 
 
@@ -65,12 +83,12 @@ class VectorField(VGroup):
 
     def __init__(
         self,
-        func: Callable[[np.ndarray], np.ndarray],
-        color: Color | None = None,
-        color_scheme: Callable[[np.ndarray], float] | None = None,
+        func: Callable[[Point3D], Vector3D],
+        color: ParsableManimColor | None = None,
+        color_scheme: Callable[[Vector3D], 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)
@@ -79,13 +97,13 @@ class VectorField(VGroup):
             self.single_color = False
             if color_scheme is None:
 
-                def color_scheme(p):
-                    return np.linalg.norm(p)
+                def color_scheme(vec: Vector3D) -> float:
+                    return np.linalg.norm(vec)
 
             self.color_scheme = color_scheme  # TODO maybe other default for direction?
-            self.rgbs = np.array(list(map(color_to_rgb, colors)))
+            self.rgbs: FloatRGB_Array = np.array(list(map(color_to_rgb, colors)))
 
-            def pos_to_rgb(pos: np.ndarray) -> tuple[float, float, float, float]:
+            def pos_to_rgb(pos: Point3D) -> FloatRGB:
                 vec = self.func(pos)
                 color_value = np.clip(
                     self.color_scheme(vec),
@@ -98,8 +116,8 @@ class VectorField(VGroup):
                     color_value,
                 )
                 alpha *= len(self.rgbs) - 1
-                c1 = self.rgbs[int(alpha)]
-                c2 = self.rgbs[min(int(alpha + 1), len(self.rgbs) - 1)]
+                c1: FloatRGB = self.rgbs[int(alpha)]
+                c2: FloatRGB = self.rgbs[min(int(alpha + 1), len(self.rgbs) - 1)]
                 alpha %= 1
                 return interpolate(c1, c2, alpha)
 
@@ -107,7 +125,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
@@ -344,7 +362,6 @@ class VectorField(VGroup):
             This vector field.
 
         """
-
         self.stop_submobject_movement()
         self.submob_movement_updater = lambda mob, dt: mob.nudge_submobjects(
             dt * speed,
@@ -409,8 +426,8 @@ class VectorField(VGroup):
         self,
         start: float,
         end: float,
-        colors: Iterable,
-    ):
+        colors: Iterable[ParsableManimColor],
+    ) -> Callable[[Sequence[float], float], FloatRGBA_Array]:
         """
         Generates a gradient of rgbas as a numpy array
 
@@ -427,9 +444,9 @@ class VectorField(VGroup):
         -------
             function to generate the gradients as numpy arrays representing rgba values
         """
-        rgbs = np.array([color_to_rgb(c) for c in colors])
+        rgbs: FloatRGB_Array = np.array([color_to_rgb(c) for c in colors])
 
-        def func(values, opacity=1):
+        def func(values: Sequence[float], opacity: float = 1.0) -> FloatRGBA_Array:
             alphas = inverse_interpolate(start, end, np.array(values))
             alphas = np.clip(alphas, 0, 1)
             scaled_alphas = alphas * (len(rgbs) - 1)
@@ -437,12 +454,14 @@ class VectorField(VGroup):
             next_indices = np.clip(indices + 1, 0, len(rgbs) - 1)
             inter_alphas = scaled_alphas % 1
             inter_alphas = inter_alphas.repeat(3).reshape((len(indices), 3))
-            result = interpolate(rgbs[indices], rgbs[next_indices], inter_alphas)
-            result = np.concatenate(
-                (result, np.full([len(result), 1], opacity)),
+            new_rgbs: FloatRGB_Array = interpolate(
+                rgbs[indices], rgbs[next_indices], inter_alphas
+            )
+            new_rgbas: FloatRGBA_Array = np.concatenate(
+                (new_rgbs, np.full([len(new_rgbs), 1], opacity)),
                 axis=1,
             )
-            return result
+            return new_rgbas
 
         return func
 
@@ -533,11 +552,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 +632,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 +726,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,
@@ -821,7 +840,9 @@ class StreamLines(VectorField):
             step = max(1, int(len(points) / self.max_anchors_per_line))
             line.set_points_smoothly(points[::step])
             if self.single_color:
-                line.set_stroke(self.color)
+                line.set_stroke(
+                    color=self.color, width=self.stroke_width, opacity=opacity
+                )
             else:
                 if config.renderer == RendererType.OPENGL:
                     # scaled for compatibility with cairo
@@ -940,7 +961,6 @@ class StreamLines(VectorField):
                     self.wait(stream_lines.virtual_time / stream_lines.flow_speed)
 
         """
-
         for line in self.stream_lines:
             run_time = line.duration / flow_speed
             line.anim = line_animation_class(
@@ -1000,7 +1020,6 @@ class StreamLines(VectorField):
                     self.play(stream_lines.end_animation())
 
         """
-
         if self.flow_animation is None:
             raise ValueError("You have to start the animation before fading it out.")
 

manim/opengl/__init__.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
-try:
+import contextlib
+
+with contextlib.suppress(ImportError):
     from dearpygui import dearpygui as dpg
-except ImportError:
-    pass
 
 
 from manim.mobject.opengl.dot_cloud import *

manim/plugins/__init__.py

@@ -1,3 +1,16 @@
 from __future__ import annotations
 
-from .import_plugins import *
+from manim._config import config, logger
+from manim.plugins.plugins_flags import get_plugins, list_plugins
+
+__all__ = [
+    "get_plugins",
+    "list_plugins",
+]
+
+requested_plugins: set[str] = set(config["plugins"])
+missing_plugins = requested_plugins - set(get_plugins().keys())
+
+
+if missing_plugins:
+    logger.warning("Missing Plugins: %s", missing_plugins)

manim/plugins/plugins_flags.py

@@ -1,30 +1,26 @@
-"""
-plugins_flags.py
-------------
-
-Plugin Managing Utility.
-"""
+"""Plugin Managing Utility"""
 
 from __future__ import annotations
 
-import pkg_resources
+from importlib.metadata import entry_points
+from typing import Any
 
-from manim import console
+from manim._config import console
 
 __all__ = ["list_plugins"]
 
 
-def get_plugins():
-    plugins = {
+def get_plugins() -> dict[str, Any]:
+    plugins: dict[str, Any] = {
         entry_point.name: entry_point.load()
-        for entry_point in pkg_resources.iter_entry_points("manim.plugins")
+        for entry_point in entry_points(group="manim.plugins")
     }
     return plugins
 
 
-def list_plugins():
+def list_plugins() -> None:
     console.print("[green bold]Plugins:[/green bold]", justify="left")
 
     plugins = get_plugins()
-    for plugin in plugins:
-        console.print(f" • {plugin}")
+    for plugin_name in plugins:
+        console.print(f" • {plugin_name}")