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

manim/mobject/svg/svg_mobject.py

@@ -441,9 +441,9 @@ class SVGMobject(VMobject, metaclass=ConvertToOpenGL):
         if self.should_center:
             self.center()
         if self.svg_height is not None:
-            self.set_height(self.svg_height)
+            self.set(height=self.svg_height)
         if self.svg_width is not None:
-            self.set_width(self.svg_width)
+            self.set(width=self.svg_width)
 
 
 class VMobjectFromSVGPath(VMobject, metaclass=ConvertToOpenGL):
@@ -510,17 +510,15 @@ class VMobjectFromSVGPath(VMobject, metaclass=ConvertToOpenGL):
         all_points: list[np.ndarray] = []
         last_move = None
         curve_start = None
+        last_true_move = None
 
-        # These lambdas behave the same as similar functions in
-        # vectorized_mobject, except they add to a list of points instead
-        # of updating this Mobject's numpy array of points. This way,
-        # we don't observe O(n^2) behavior for complex paths due to
-        # numpy's need to re-allocate memory on every append.
-        def move_pen(pt):
-            nonlocal last_move, curve_start
+        def move_pen(pt, *, true_move: bool = False):
+            nonlocal last_move, curve_start, last_true_move
             last_move = pt
             if curve_start is None:
                 curve_start = last_move
+            if true_move:
+                last_true_move = last_move
 
         if self.n_points_per_curve == 4:
 
@@ -568,7 +566,7 @@ class VMobjectFromSVGPath(VMobject, metaclass=ConvertToOpenGL):
         for segment in self.path_obj:
             segment_class = segment.__class__
             if segment_class == se.Move:
-                move_pen(_convert_point_to_3d(*segment.end))
+                move_pen(_convert_point_to_3d(*segment.end), true_move=True)
             elif segment_class == se.Line:
                 add_line(last_move, _convert_point_to_3d(*segment.end))
             elif segment_class == se.QuadraticBezier:
@@ -588,8 +586,8 @@ class VMobjectFromSVGPath(VMobject, metaclass=ConvertToOpenGL):
                 # If the SVG path naturally ends at the beginning of the curve,
                 # we do *not* need to draw a closing line. To account for floating
                 # point precision, we use a small value to compare the two points.
-                if abs(np.linalg.norm(last_move - curve_start)) > 0.0001:
-                    add_line(last_move, curve_start)
+                if abs(np.linalg.norm(last_move - last_true_move)) > 0.0001:
+                    add_line(last_move, last_true_move)
                 curve_start = None
             else:
                 raise AssertionError(f"Not implemented: {segment_class}")

manim/mobject/table.py

@@ -74,7 +74,6 @@ from manim.mobject.text.numbers import DecimalNumber, Integer
 from manim.mobject.text.tex_mobject import MathTex
 from manim.mobject.text.text_mobject import Paragraph
 
-from .. import config
 from ..animation.animation import Animation
 from ..animation.composition import AnimationGroup
 from ..animation.creation import Create, Write

manim/mobject/text/code_mobject.py

@@ -26,6 +26,8 @@ from manim.mobject.text.text_mobject import Paragraph
 from manim.mobject.types.vectorized_mobject import VGroup
 from manim.utils.color import WHITE
 
+__all__ = ["Code"]
+
 
 class Code(VGroup):
     """A highlighted source code listing.

manim/mobject/text/numbers.py

@@ -18,6 +18,8 @@ from manim.mobject.value_tracker import ValueTracker
 
 string_to_mob_map = {}
 
+__all__ = ["DecimalNumber", "Integer", "Variable"]
+
 
 class DecimalNumber(VMobject, metaclass=ConvertToOpenGL):
     """An mobject representing a decimal number.

manim/mobject/text/tex_mobject.py

@@ -34,7 +34,7 @@ from manim import config, logger
 from manim.constants import *
 from manim.mobject.geometry.line import Line
 from manim.mobject.svg.svg_mobject import SVGMobject
-from manim.mobject.types.vectorized_mobject import VectorizedPoint, VGroup, VMobject
+from manim.mobject.types.vectorized_mobject import VGroup, VMobject
 from manim.utils.tex import TexTemplate
 from manim.utils.tex_file_writing import tex_to_svg_file
 

manim/mobject/text/text_mobject.py

@@ -49,6 +49,8 @@ Examples
 
 from __future__ import annotations
 
+import functools
+
 __all__ = ["Text", "Paragraph", "MarkupText", "register_font"]
 
 
@@ -77,6 +79,8 @@ TEXT_MOB_SCALE_FACTOR = 0.05
 DEFAULT_LINE_SPACING_SCALE = 0.3
 TEXT2SVG_ADJUSTMENT_FACTOR = 4.8
 
+__all__ = ["Text", "Paragraph", "MarkupText", "register_font"]
+
 
 def remove_invisible_chars(mobject: SVGMobject) -> SVGMobject:
     """Function to remove unwanted invisible characters from some mobjects.
@@ -350,7 +354,7 @@ class Text(SVGMobject):
                )
                 text6.scale(1.3).shift(DOWN)
                 self.add(text1, text2, text3, text4, text5 , text6)
-                Group(*self.mobjects).arrange(DOWN, buff=.8).set_height(config.frame_height-LARGE_BUFF)
+                Group(*self.mobjects).arrange(DOWN, buff=.8).set(height=config.frame_height-LARGE_BUFF)
 
     .. manim:: TextMoreCustomization
             :save_last_frame:
@@ -407,6 +411,11 @@ class Text(SVGMobject):
 
     """
 
+    @staticmethod
+    @functools.lru_cache(maxsize=None)
+    def font_list() -> list[str]:
+        return manimpango.list_fonts()
+
     def __init__(
         self,
         text: str,
@@ -431,13 +440,25 @@ class Text(SVGMobject):
         width: float = None,
         should_center: bool = True,
         disable_ligatures: bool = False,
+        use_svg_cache: bool = False,
         **kwargs,
     ) -> None:
         self.line_spacing = line_spacing
         if font and warn_missing_font:
-            fonts_list = manimpango.list_fonts()
+            fonts_list = Text.font_list()
+            # handle special case of sans/sans-serif
+            if font.lower() == "sans-serif":
+                font = "sans"
             if font not in fonts_list:
-                logger.warning(f"Font {font} not in {fonts_list}.")
+                # check if the capitalized version is in the supported fonts
+                if font.capitalize() in fonts_list:
+                    font = font.capitalize()
+                elif font.lower() in fonts_list:
+                    font = font.lower()
+                elif font.title() in fonts_list:
+                    font = font.title()
+                else:
+                    logger.warning(f"Font {font} not in {fonts_list}.")
         self.font = font
         self._font_size = float(font_size)
         # needs to be a float or else size is inflated when font_size = 24
@@ -491,7 +512,7 @@ class Text(SVGMobject):
             height=height,
             width=width,
             should_center=should_center,
-            use_svg_cache=False,
+            use_svg_cache=use_svg_cache,
             **kwargs,
         )
         self.text = text
@@ -1133,6 +1154,11 @@ class MarkupText(SVGMobject):
 
     """
 
+    @staticmethod
+    @functools.lru_cache(maxsize=None)
+    def font_list() -> list[str]:
+        return manimpango.list_fonts()
+
     def __init__(
         self,
         text: str,
@@ -1157,9 +1183,20 @@ class MarkupText(SVGMobject):
         self.text = text
         self.line_spacing = line_spacing
         if font and warn_missing_font:
-            fonts_list = manimpango.list_fonts()
+            fonts_list = Text.font_list()
+            # handle special case of sans/sans-serif
+            if font.lower() == "sans-serif":
+                font = "sans"
             if font not in fonts_list:
-                logger.warning(f"Font {font} not in {fonts_list}.")
+                # check if the capitalized version is in the supported fonts
+                if font.capitalize() in fonts_list:
+                    font = font.capitalize()
+                elif font.lower() in fonts_list:
+                    font = font.lower()
+                elif font.title() in fonts_list:
+                    font = font.title()
+                else:
+                    logger.warning(f"Font {font} not in {fonts_list}.")
         self.font = font
         self._font_size = float(font_size)
         self.slant = slant

manim/mobject/three_d/three_d_utils.py

@@ -22,7 +22,7 @@ from manim.constants import ORIGIN, UP
 from manim.utils.space_ops import get_unit_normal
 
 if TYPE_CHECKING:
-    from manim.typing import Point3D, Vector
+    from manim.typing import Point3D, Vector3D
 
 
 def get_3d_vmob_gradient_start_and_end_points(vmob) -> tuple[Point3D, Point3D]:
@@ -52,7 +52,7 @@ def get_3d_vmob_end_corner(vmob) -> Point3D:
     return vmob.points[get_3d_vmob_end_corner_index(vmob)]
 
 
-def get_3d_vmob_unit_normal(vmob, point_index: int) -> Vector:
+def get_3d_vmob_unit_normal(vmob, point_index: int) -> Vector3D:
     n_points = vmob.get_num_points()
     if len(vmob.get_anchors()) <= 2:
         return np.array(UP)
@@ -68,9 +68,9 @@ def get_3d_vmob_unit_normal(vmob, point_index: int) -> Vector:
     return unit_normal
 
 
-def get_3d_vmob_start_corner_unit_normal(vmob) -> Vector:
+def get_3d_vmob_start_corner_unit_normal(vmob) -> Vector3D:
     return get_3d_vmob_unit_normal(vmob, get_3d_vmob_start_corner_index(vmob))
 
 
-def get_3d_vmob_end_corner_unit_normal(vmob) -> Vector:
+def get_3d_vmob_end_corner_unit_normal(vmob) -> Vector3D:
     return get_3d_vmob_unit_normal(vmob, get_3d_vmob_end_corner_index(vmob))

manim/mobject/three_d/three_dimensions.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from manim.typing import Point3D, Vector3
+from manim.typing import Point3D, Vector3D
 from manim.utils.color import BLUE, BLUE_D, BLUE_E, LIGHT_GREY, WHITE, interpolate_color
 
 __all__ = [
@@ -953,7 +953,7 @@ class Line3D(Cylinder):
     def pointify(
         self,
         mob_or_point: Mobject | Point3D,
-        direction: Vector3 = None,
+        direction: Vector3D = None,
     ) -> np.ndarray:
         """Gets a point representing the center of the :class:`Mobjects <.Mobject>`.
 
@@ -1001,7 +1001,7 @@ class Line3D(Cylinder):
     def parallel_to(
         cls,
         line: Line3D,
-        point: Vector3 = ORIGIN,
+        point: Vector3D = ORIGIN,
         length: float = 5,
         **kwargs,
     ) -> Line3D:
@@ -1049,7 +1049,7 @@ class Line3D(Cylinder):
     def perpendicular_to(
         cls,
         line: Line3D,
-        point: Vector3 = ORIGIN,
+        point: Vector3D = ORIGIN,
         length: float = 5,
         **kwargs,
     ) -> Line3D:

manim/mobject/types/image_mobject.py

@@ -19,6 +19,8 @@ from ...utils.bezier import interpolate
 from ...utils.color import WHITE, ManimColor, color_to_int_rgb
 from ...utils.images import change_to_rgba_array, get_full_raster_image_path
 
+__all__ = ["ImageMobject", "ImageMobjectFromCamera"]
+
 
 class AbstractImageMobject(Mobject):
     """
@@ -191,7 +193,9 @@ class ImageMobject(AbstractImageMobject):
             self.pixel_array, self.pixel_array_dtype
         )
         if self.invert:
-            self.pixel_array[:, :, :3] = 255 - self.pixel_array[:, :, :3]
+            self.pixel_array[:, :, :3] = (
+                np.iinfo(self.pixel_array_dtype).max - self.pixel_array[:, :, :3]
+            )
         super().__init__(scale_to_resolution, **kwargs)
 
     def get_pixel_array(self):

manim/mobject/types/point_cloud_mobject.py

@@ -23,6 +23,8 @@ from ...utils.color import (
 )
 from ...utils.iterables import stretch_array_to_length
 
+__all__ = ["PMobject", "Mobject1D", "Mobject2D", "PGroup", "PointCloudDot", "Point"]
+
 
 class PMobject(Mobject, metaclass=ConvertToOpenGL):
     """A disc made of a cloud of Dots

manim/mobject/types/vectorized_mobject.py

@@ -26,20 +26,17 @@ from typing import (
 )
 
 import numpy as np
-import numpy.typing as npt
 from PIL.Image import Image
-from typing_extensions import Self
 
+from manim import config
+from manim.constants import *
+from manim.mobject.mobject import Mobject
 from manim.mobject.opengl.opengl_compatibility import ConvertToOpenGL
 from manim.mobject.opengl.opengl_vectorized_mobject import OpenGLVMobject
 from manim.mobject.three_d.three_d_utils import (
     get_3d_vmob_gradient_start_and_end_points,
 )
-
-from ... import config
-from ...constants import *
-from ...mobject.mobject import Mobject
-from ...utils.bezier import (
+from manim.utils.bezier import (
     bezier,
     get_smooth_handle_points,
     integer_interpolate,
@@ -47,11 +44,19 @@ from ...utils.bezier import (
     partial_bezier_points,
     proportions_along_bezier_curve_for_point,
 )
-from ...utils.color import BLACK, WHITE, ManimColor, ParsableManimColor
-from ...utils.iterables import make_even, resize_array, stretch_array_to_length, tuplify
-from ...utils.space_ops import rotate_vector, shoelace_direction
+from manim.utils.color import BLACK, WHITE, ManimColor, ParsableManimColor
+from manim.utils.iterables import (
+    make_even,
+    resize_array,
+    stretch_array_to_length,
+    tuplify,
+)
+from manim.utils.space_ops import rotate_vector, shoelace_direction
 
 if TYPE_CHECKING:
+    import numpy.typing as npt
+    from typing_extensions import Self
+
     from manim.typing import (
         BezierPoints,
         CubicBezierPoints,
@@ -62,7 +67,7 @@ if TYPE_CHECKING:
         Point3D_Array,
         QuadraticBezierPoints,
         RGBA_Array_Float,
-        Vector3,
+        Vector3D,
         Zeros,
     )
 
@@ -74,6 +79,16 @@ if TYPE_CHECKING:
 # - Think about length of self.points.  Always 0 or 1 mod 4?
 #   That's kind of weird.
 
+__all__ = [
+    "VMobject",
+    "VGroup",
+    "VDict",
+    "VectorizedPoint",
+    "CurvesAsSubmobjects",
+    "VectorizedPoint",
+    "DashedVMobject",
+]
+
 
 class VMobject(Mobject):
     """A vectorized mobject.
@@ -114,7 +129,7 @@ class VMobject(Mobject):
         background_stroke_width: float = 0,
         sheen_factor: float = 0.0,
         joint_type: LineJointType | None = None,
-        sheen_direction: Vector3 = UL,
+        sheen_direction: Vector3D = UL,
         close_new_points: bool = False,
         pre_function_handle_to_anchor_scale_factor: float = 0.01,
         make_smooth_after_applying_functions: bool = False,
@@ -123,6 +138,7 @@ class VMobject(Mobject):
         # TODO, do we care about accounting for varying zoom levels?
         tolerance_for_point_equality: float = 1e-6,
         n_points_per_cubic_curve: int = 4,
+        cap_style: CapStyleType = CapStyleType.AUTO,
         **kwargs,
     ):
         self.fill_opacity = fill_opacity
@@ -138,7 +154,7 @@ class VMobject(Mobject):
         self.joint_type: LineJointType = (
             LineJointType.AUTO if joint_type is None else joint_type
         )
-        self.sheen_direction: Vector3 = sheen_direction
+        self.sheen_direction: Vector3D = sheen_direction
         self.close_new_points: bool = close_new_points
         self.pre_function_handle_to_anchor_scale_factor: float = (
             pre_function_handle_to_anchor_scale_factor
@@ -150,6 +166,7 @@ class VMobject(Mobject):
         self.shade_in_3d: bool = shade_in_3d
         self.tolerance_for_point_equality: float = tolerance_for_point_equality
         self.n_points_per_cubic_curve: int = n_points_per_cubic_curve
+        self.cap_style: CapStyleType = cap_style
         super().__init__(**kwargs)
         self.submobjects: list[VMobject]
 
@@ -335,11 +352,39 @@ class VMobject(Mobject):
             setattr(self, opacity_name, opacity)
         if color is not None and background:
             if isinstance(color, (list, tuple)):
-                self.background_stroke_color = color
+                self.background_stroke_color = ManimColor.parse(color)
             else:
                 self.background_stroke_color = ManimColor(color)
         return self
 
+    def set_cap_style(self, cap_style: CapStyleType) -> Self:
+        """
+        Sets the cap style of the :class:`VMobject`.
+
+        Parameters
+        ----------
+        cap_style
+            The cap style to be set. See :class:`.CapStyleType` for options.
+
+        Returns
+        -------
+        :class:`VMobject`
+            ``self``
+
+        Examples
+        --------
+        .. manim:: CapStyleExample
+            :save_last_frame:
+
+            class CapStyleExample(Scene):
+                def construct(self):
+                    line = Line(LEFT, RIGHT, color=YELLOW, stroke_width=20)
+                    line.set_cap_style(CapStyleType.ROUND)
+                    self.add(line)
+        """
+        self.cap_style = cap_style
+        return self
+
     def set_background_stroke(self, **kwargs) -> Self:
         kwargs["background"] = True
         self.set_stroke(**kwargs)
@@ -356,7 +401,7 @@ class VMobject(Mobject):
         background_stroke_width: float | None = None,
         background_stroke_opacity: float | None = None,
         sheen_factor: float | None = None,
-        sheen_direction: Vector3 | None = None,
+        sheen_direction: Vector3D | None = None,
         background_image: Image | str | None = None,
         family: bool = True,
     ) -> Self:
@@ -523,7 +568,7 @@ class VMobject(Mobject):
 
     color = property(get_color, set_color)
 
-    def set_sheen_direction(self, direction: Vector3, family: bool = True) -> Self:
+    def set_sheen_direction(self, direction: Vector3D, family: bool = True) -> Self:
         """Sets the direction of the applied sheen.
 
         Parameters
@@ -548,11 +593,11 @@ class VMobject(Mobject):
             for submob in self.get_family():
                 submob.sheen_direction = direction
         else:
-            self.sheen_direction: Vector3 = direction
+            self.sheen_direction: Vector3D = direction
         return self
 
     def rotate_sheen_direction(
-        self, angle: float, axis: Vector3 = OUT, family: bool = True
+        self, angle: float, axis: Vector3D = OUT, family: bool = True
     ) -> Self:
         """Rotates the direction of the applied sheen.
 
@@ -585,7 +630,7 @@ class VMobject(Mobject):
         return self
 
     def set_sheen(
-        self, factor: float, direction: Vector3 | None = None, family: bool = True
+        self, factor: float, direction: Vector3D | None = None, family: bool = True
     ) -> Self:
         """Applies a color gradient from a direction.
 
@@ -623,7 +668,7 @@ class VMobject(Mobject):
             self.set_fill(self.get_fill_color(), family=family)
         return self
 
-    def get_sheen_direction(self) -> Vector3:
+    def get_sheen_direction(self) -> Vector3D:
         return np.array(self.sheen_direction)
 
     def get_sheen_factor(self) -> float:
@@ -917,6 +962,27 @@ class VMobject(Mobject):
         -------
         :class:`VMobject`
             ``self``
+
+
+        Examples
+        --------
+        .. manim:: PointsAsCornersExample
+            :save_last_frame:
+
+            class PointsAsCornersExample(Scene):
+                def construct(self):
+                    corners = (
+                        # create square
+                        UR, UL,
+                        DL, DR,
+                        UR,
+                        # create crosses
+                        DL, UL,
+                        DR
+                    )
+                    vmob = VMobject(stroke_color=RED)
+                    vmob.set_points_as_corners(corners).scale(2)
+                    self.add(vmob)
         """
         nppcc = self.n_points_per_cubic_curve
         points = np.array(points)
@@ -998,7 +1064,7 @@ class VMobject(Mobject):
     def rotate(
         self,
         angle: float,
-        axis: Vector3 = OUT,
+        axis: Vector3D = OUT,
         about_point: Point3D | None = None,
         **kwargs,
     ) -> Self:
@@ -1342,6 +1408,22 @@ class VMobject(Mobject):
             If ``alpha`` is not between 0 and 1.
         :exc:`Exception`
             If the :class:`VMobject` has no points.
+
+        Example
+        -------
+        .. manim:: PointFromProportion
+            :save_last_frame:
+
+            class PointFromProportion(Scene):
+                def construct(self):
+                    line = Line(2*DL, 2*UR)
+                    self.add(line)
+                    colors = (RED, BLUE, YELLOW)
+                    proportions = (1/4, 1/2, 3/4)
+                    for color, proportion in zip(colors, proportions):
+                        self.add(Dot(color=color).move_to(
+                                line.point_from_proportion(proportion)
+                        ))
         """
 
         if alpha < 0 or alpha > 1:
@@ -1366,6 +1448,9 @@ class VMobject(Mobject):
                 return curve(residue)
 
             current_length += length
+        raise Exception(
+            "Not sure how you reached here, please file a bug report at https://github.com/ManimCommunity/manim/issues/new/choose"
+        )
 
     def proportion_from_point(
         self,
@@ -1468,9 +1553,10 @@ class VMobject(Mobject):
         """
         if self.points.shape[0] == 1:
             return self.points
-        return np.array(
-            tuple(it.chain(*zip(self.get_start_anchors(), self.get_end_anchors()))),
-        )
+
+        s = self.get_start_anchors()
+        e = self.get_end_anchors()
+        return list(it.chain.from_iterable(zip(s, e)))
 
     def get_points_defining_boundary(self) -> Point3D_Array:
         # Probably returns all anchors, but this is weird regarding  the name of the method.
@@ -1690,7 +1776,10 @@ class VMobject(Mobject):
                 interpolate(getattr(mobject1, attr), getattr(mobject2, attr), alpha),
             )
             if alpha == 1.0:
-                setattr(self, attr, getattr(mobject2, attr))
+                val = getattr(mobject2, attr)
+                if isinstance(val, np.ndarray):
+                    val = val.copy()
+                setattr(self, attr, val)
 
     def pointwise_become_partial(
         self,
@@ -1963,8 +2052,14 @@ class VGroup(VMobject, metaclass=ConvertToOpenGL):
                         (gr-circle_red).animate.shift(RIGHT)
                     )
         """
-        if not all(isinstance(m, (VMobject, OpenGLVMobject)) for m in vmobjects):
-            raise TypeError("All submobjects must be of type VMobject")
+        for m in vmobjects:
+            if not isinstance(m, (VMobject, OpenGLVMobject)):
+                raise TypeError(
+                    f"All submobjects of {self.__class__.__name__} must be of type VMobject. "
+                    f"Got {repr(m)} ({type(m).__name__}) instead. "
+                    "You can try using `Group` instead."
+                )
+
         return super().add(*vmobjects)
 
     def __add__(self, vmobject: VMobject) -> Self:
@@ -2458,7 +2553,7 @@ class CurvesAsSubmobjects(VGroup):
         if len(self.submobjects) == 0:
             caller_name = sys._getframe(1).f_code.co_name
             raise Exception(
-                f"Cannot call CurvesAsSubmobjects.{caller_name} for a CurvesAsSubmobject with no submobjects"
+                f"Cannot call CurvesAsSubmobjects. {caller_name} for a CurvesAsSubmobject with no submobjects"
             )
 
     def _get_submobjects_with_points(self):
@@ -2468,7 +2563,7 @@ class CurvesAsSubmobjects(VGroup):
         if len(submobjs_with_pts) == 0:
             caller_name = sys._getframe(1).f_code.co_name
             raise Exception(
-                f"Cannot call CurvesAsSubmobjects.{caller_name} for a CurvesAsSubmobject whose submobjects have no points"
+                f"Cannot call CurvesAsSubmobjects. {caller_name} for a CurvesAsSubmobject whose submobjects have no points"
             )
         return submobjs_with_pts
 

manim/mobject/value_tracker.py

@@ -45,7 +45,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))
@@ -71,7 +71,7 @@ class ValueTracker(Mobject, metaclass=ConvertToOpenGL):
 
     def __init__(self, value=0, **kwargs):
         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:
@@ -132,7 +132,7 @@ class ValueTracker(Mobject, metaclass=ConvertToOpenGL):
         Turns self into an interpolation between mobject1
         and mobject2.
         """
-        self.set_points(path_func(mobject1.points, mobject2.points, alpha))
+        self.set(points=path_func(mobject1.points, mobject2.points, alpha))
         return self
 
 

manim/mobject/vector_field.py

@@ -829,7 +829,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

manim/plugins/__init__.py

@@ -1,3 +1,17 @@
 from __future__ import annotations
 
-from .import_plugins import *
+from manim import config, logger
+
+from .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)