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

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
 
 
@@ -165,7 +165,8 @@ class ComplexValueTracker(ValueTracker):
         """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."""
+        to represent the value geometrically, see the usage example.
+        """
         return complex(*self.points[0, :2])
 
     def set_value(self, z):

manim/mobject/vector_field.py

@@ -10,8 +10,9 @@ __all__ = [
 
 import itertools as it
 import random
+from collections.abc import Iterable, Sequence
 from math import ceil, floor
-from typing import Callable, Iterable, Sequence
+from typing import Callable
 
 import numpy as np
 from PIL import Image
@@ -352,7 +353,6 @@ class VectorField(VGroup):
             This vector field.
 
         """
-
         self.stop_submobject_movement()
         self.submob_movement_updater = lambda mob, dt: mob.nudge_submobjects(
             dt * speed,
@@ -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
@@ -948,7 +950,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(
@@ -1008,7 +1009,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

@@ -2,24 +2,30 @@
 
 from __future__ import annotations
 
-import pkg_resources
+import sys
+from typing import Any
 
-from manim import console
+if sys.version_info < (3, 10):
+    from importlib_metadata import entry_points
+else:
+    from importlib.metadata import entry_points
+
+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}")

manim/renderer/cairo_renderer.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import typing
-from typing import Any
 
 import numpy as np
 
@@ -9,14 +8,21 @@ from manim.utils.hashing import get_hash_from_play_call
 
 from .. import config, logger
 from ..camera.camera import Camera
-from ..mobject.mobject import Mobject
+from ..mobject.mobject import Mobject, _AnimationBuilder
 from ..scene.scene_file_writer import SceneFileWriter
 from ..utils.exceptions import EndSceneEarlyException
 from ..utils.iterables import list_update
 
 if typing.TYPE_CHECKING:
+    from typing import Any
+
+    from manim.animation.animation import Animation
     from manim.scene.scene import Scene
 
+    from ..typing import PixelArray
+
+__all__ = ["CairoRenderer"]
+
 
 class CairoRenderer:
     """A renderer using Cairo.
@@ -51,7 +57,12 @@ class CairoRenderer:
             scene.__class__.__name__,
         )
 
-    def play(self, scene, *args, **kwargs):
+    def play(
+        self,
+        scene: Scene,
+        *args: Animation | Mobject | _AnimationBuilder,
+        **kwargs,
+    ):
         # Reset skip_animations to the original state.
         # Needed when rendering only some animations, and skipping others.
         self.skip_animations = self._original_skipping_status
@@ -149,7 +160,7 @@ class CairoRenderer:
         self.update_frame(scene, moving_mobjects)
         self.add_frame(self.get_frame())
 
-    def get_frame(self):
+    def get_frame(self) -> PixelArray:
         """
         Gets the current frame as NumPy array.
 
@@ -176,8 +187,7 @@ class CairoRenderer:
         if self.skip_animations:
             return
         self.time += num_frames * dt
-        for _ in range(num_frames):
-            self.file_writer.write_frame(frame)
+        self.file_writer.write_frame(frame, num_frames=num_frames)
 
     def freeze_current_frame(self, duration: float):
         """Adds a static frame to the movie for a given duration. The static frame is the current frame.
@@ -242,13 +252,13 @@ class CairoRenderer:
         if config["save_last_frame"]:
             self.skip_animations = True
         if (
-            config["from_animation_number"]
-            and self.num_plays < config["from_animation_number"]
+            config.from_animation_number > 0
+            and self.num_plays < config.from_animation_number
         ):
             self.skip_animations = True
         if (
-            config["upto_animation_number"]
-            and self.num_plays > config["upto_animation_number"]
+            config.upto_animation_number >= 0
+            and self.num_plays > config.upto_animation_number
         ):
             self.skip_animations = True
             raise EndSceneEarlyException()

manim/renderer/opengl_renderer.py

@@ -1,15 +1,11 @@
 from __future__ import annotations
 
+import contextlib
 import itertools as it
-import sys
 import time
+from functools import cached_property
 from typing import Any
 
-if sys.version_info < (3, 8):
-    from backports.cached_property import cached_property
-else:
-    from functools import cached_property
-
 import moderngl
 import numpy as np
 from PIL import Image
@@ -39,6 +35,8 @@ from .vectorized_mobject_rendering import (
     render_opengl_vectorized_mobject_stroke,
 )
 
+__all__ = ["OpenGLCamera", "OpenGLRenderer"]
+
 
 class OpenGLCamera(OpenGLMobject):
     euler_angles = _Data()
@@ -65,12 +63,12 @@ class OpenGLCamera(OpenGLMobject):
         if self.orthographic:
             self.projection_matrix = opengl.orthographic_projection_matrix()
             self.unformatted_projection_matrix = opengl.orthographic_projection_matrix(
-                format=False,
+                format_=False,
             )
         else:
             self.projection_matrix = opengl.perspective_projection_matrix()
             self.unformatted_projection_matrix = opengl.perspective_projection_matrix(
-                format=False,
+                format_=False,
             )
 
         if frame_shape is None:
@@ -217,11 +215,12 @@ class OpenGLCamera(OpenGLMobject):
         self.refresh_rotation_matrix()
 
 
-points_per_curve = 3
-
-
 class OpenGLRenderer:
-    def __init__(self, file_writer_class=SceneFileWriter, skip_animations=False):
+    def __init__(
+        self,
+        file_writer_class: type[SceneFileWriter] = SceneFileWriter,
+        skip_animations: bool = False,
+    ) -> None:
         # Measured in pixel widths, used for vector graphics
         self.anti_alias_width = 1.5
         self._file_writer_class = file_writer_class
@@ -342,10 +341,8 @@ class OpenGLRenderer:
                 shader_wrapper.uniforms.items(),
                 self.perspective_uniforms.items(),
             ):
-                try:
+                with contextlib.suppress(KeyError):
                     shader.set_uniform(name, value)
-                except KeyError:
-                    pass
             try:
                 shader.set_uniform(
                     "u_view_matrix", self.scene.camera.formatted_view_matrix
@@ -391,7 +388,7 @@ class OpenGLRenderer:
 
         return self.path_to_texture_id[repr(path)]
 
-    def update_skipping_status(self):
+    def update_skipping_status(self) -> None:
         """
         This method is used internally to check if the current
         animation needs to be skipped or not. It also checks if
@@ -403,13 +400,13 @@ class OpenGLRenderer:
         if self.file_writer.sections[-1].skip_animations:
             self.skip_animations = True
         if (
-            config["from_animation_number"]
-            and self.num_plays < config["from_animation_number"]
+            config.from_animation_number > 0
+            and self.num_plays < config.from_animation_number
         ):
             self.skip_animations = True
         if (
-            config["upto_animation_number"]
-            and self.num_plays > config["upto_animation_number"]
+            config.upto_animation_number >= 0
+            and self.num_plays > config.upto_animation_number
         ):
             self.skip_animations = True
             raise EndSceneEarlyException()
@@ -426,8 +423,9 @@ class OpenGLRenderer:
             self.update_frame(scene)
 
             if not self.skip_animations:
-                for _ in range(int(config.frame_rate * scene.duration)):
-                    self.file_writer.write_frame(self)
+                self.file_writer.write_frame(
+                    self, num_frames=int(config.frame_rate * scene.duration)
+                )
 
             if self.window is not None:
                 self.window.swap_buffers()
@@ -573,7 +571,7 @@ class OpenGLRenderer:
         if pixel_shape is None:
             return np.array([0, 0, 0])
         pw, ph = pixel_shape
-        fw, fh = config["frame_width"], config["frame_height"]
+        fh = config["frame_height"]
         fc = self.camera.get_center()
         if relative:
             return 2 * np.array([px / pw, py / ph, 0])

manim/renderer/opengl_renderer_window.py

@@ -7,6 +7,8 @@ from screeninfo import get_monitors
 
 from .. import __version__, config
 
+__all__ = ["Window"]
+
 
 class Window(PygletWindow):
     fullscreen = False

manim/renderer/shader.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import contextlib
 import inspect
 import re
 import textwrap
@@ -382,10 +383,8 @@ class Shader:
             shader_program_cache[self.name] = self.shader_program
 
     def set_uniform(self, name, value):
-        try:
+        with contextlib.suppress(KeyError):
             self.shader_program[name] = value
-        except KeyError:
-            pass
 
 
 class FullScreenQuad(Mesh):

manim/renderer/shader_wrapper.py

@@ -1,20 +1,23 @@
 from __future__ import annotations
 
 import copy
+import logging
 import re
 from pathlib import Path
 
 import moderngl
 import numpy as np
 
-from .. import logger
-
 # Mobjects that should be rendered with
 # the same shader will be organized and
 # clumped together based on keeping track
 # of a dict holding all the relevant information
 # to that shader
 
+__all__ = ["ShaderWrapper"]
+
+logger = logging.getLogger("manim")
+
 
 def get_shader_dir():
     return Path(__file__).parent / "shaders"

manim/renderer/vectorized_mobject_rendering.py

@@ -8,6 +8,11 @@ from ..utils import opengl
 from ..utils.space_ops import cross2d, earclip_triangulation
 from .shader import Shader
 
+__all__ = [
+    "render_opengl_vectorized_mobject_fill",
+    "render_opengl_vectorized_mobject_stroke",
+]
+
 
 def build_matrix_lists(mob):
     root_hierarchical_matrix = mob.hierarchical_model_matrix()

manim/scene/moving_camera_scene.py

@@ -64,6 +64,25 @@ Examples
             self.play(Restore(self.camera.frame))
             self.wait()
 
+.. manim:: SlidingMultipleScenes
+
+    class SlidingMultipleScenes(MovingCameraScene):
+        def construct(self):
+            def create_scene(number):
+                frame = Rectangle(width=16,height=9)
+                circ = Circle().shift(LEFT)
+                text = Tex(f"This is Scene {str(number)}").next_to(circ, RIGHT)
+                frame.add(circ,text)
+                return frame
+
+            group = VGroup(*(create_scene(i) for i in range(4))).arrange_in_grid(buff=4)
+            self.add(group)
+            self.camera.auto_zoom(group[0], animate=False)
+            for scene in group:
+                self.play(self.camera.auto_zoom(scene))
+                self.wait()
+
+            self.play(self.camera.auto_zoom(group, margin=2))
 """
 
 from __future__ import annotations
@@ -83,8 +102,12 @@ class MovingCameraScene(Scene):
     This is a Scene, with special configurations and properties that
     make it suitable for cases where the camera must be moved around.
 
+    Note: Examples are included in the moving_camera_scene module
+    documentation, see below in the 'see also' section.
+
     .. SEEALSO::
 
+        :mod:`.moving_camera_scene`
         :class:`.MovingCamera`
     """