A community-maintained Python framework for creating mathematical animations.
from __future__ import annotations
import copy
import datetime
import threading
from unittest.mock import Mock, patch
import pytest
import srt
from manim import Manager, Scene, tempconfig
from manim._config.output import OutputFormat
from manim.animation.animation import Wait
from manim.constants import RendererType
from manim.renderer.protocol import RendererCapabilities
from manim.scene.scene import SceneInteractRerun
from manim.utils.exceptions import EndSceneEarlyException, RerunSceneException
def test_manager_attaches_to_existing_scene(dry_run):
scene = Scene()
manager = Manager(scene)
assert manager.scene is scene
assert scene.manager is manager
def test_manager_exposes_the_session_output_snapshot(config):
config.dry_run = False
config.format = "gif"
config.preview = True
scene = Scene()
manager = Manager(scene)
config.format = "none"
config.preview = False
config.dry_run = True
assert manager.output_spec.format is OutputFormat.GIF
assert manager.output_spec is scene.renderer.file_writer.output_spec
assert manager.session_spec.presentation.open_after_render is True
assert manager.session_spec.dry_run is False
def test_manager_exposes_dry_run_session_intent(config):
config.format = "gif"
config.dry_run = True
scene = Scene()
manager = Manager(scene)
config.dry_run = False
assert manager.output_spec.format is OutputFormat.NONE
assert manager.session_spec.dry_run is True
def test_post_render_preview_requires_an_artifact(dry_run):
scene = Scene()
with pytest.raises(ValueError, match="requires a media artifact"):
Manager(scene).render(preview=True)
@pytest.mark.parametrize("output_format", ["mp4", "mov", "webm", "gif"])
def test_manager_rejects_explicit_video_for_scene_without_play_calls(
config,
output_format,
):
config.format = output_format
renderer = Mock()
renderer.capabilities = RendererCapabilities()
renderer.num_plays = 0
scene = Scene(renderer)
manager = Manager(scene)
with pytest.raises(
RuntimeError,
match=f"explicitly requested {output_format.upper()}",
):
manager.post_construct()
renderer.scene_finished.assert_not_called()
def test_manager_warns_when_automatic_video_falls_back_to_still(config):
config.format = "auto"
renderer = Mock()
renderer.capabilities = RendererCapabilities()
renderer.num_plays = 0
scene = Scene(renderer)
renderer.file_writer.final_file_path = "scene.png"
manager = Manager(scene)
with patch("manim.manager.logger.warning") as warning:
manager.post_construct()
renderer.scene_finished.assert_called_once_with(scene)
warning.assert_called_once_with(
f"{scene} has no play calls. Automatic video output has been saved as a "
"PNG instead.",
)
def test_manager_rejects_second_attachment(dry_run):
scene = Scene()
manager = Manager(scene)
with pytest.raises(ValueError, match="already attached"):
Manager(scene)
assert scene.manager is manager
def test_deepcopy_leaves_clone_managerless(dry_run):
scene = Scene()
manager = Manager(scene)
scene.queue = None
clone = copy.deepcopy(scene)
assert scene.manager is manager
assert clone.manager is None
def test_scene_render_lazily_creates_manager(dry_run):
lifecycle: list[str] = []
class LifecycleScene(Scene):
def setup(self):
lifecycle.append("setup")
def construct(self):
lifecycle.append("construct")
def tear_down(self):
lifecycle.append("tear_down")
scene = LifecycleScene()
assert scene.manager is None
assert scene.render() is False
assert isinstance(scene.manager, Manager)
assert lifecycle == ["setup", "construct", "tear_down"]
def test_cli_style_render_preserves_scene_render_override(dry_run):
calls: list[bool] = []
class RenderOverrideScene(Scene):
def render(self, preview: bool = False) -> bool:
calls.append(preview)
return True
scene = RenderOverrideScene()
Manager(scene)
assert scene.render(preview=True) is True
assert calls == [True]
def test_manager_render_uses_scene_lifecycle(dry_run):
lifecycle: list[str] = []
class LifecycleScene(Scene):
def setup(self):
lifecycle.append("setup")
def construct(self):
lifecycle.append("construct")
def tear_down(self):
lifecycle.append("tear_down")
scene = LifecycleScene()
assert Manager(scene).render() is False
assert lifecycle == ["setup", "construct", "tear_down"]
def test_manager_render_uses_lifecycle_hooks(dry_run):
hooks: list[str] = []
class HookManager(Manager[Scene]):
def setup(self):
hooks.append("setup")
super().setup()
def construct(self):
hooks.append("construct")
super().construct()
def tear_down(self):
hooks.append("tear_down")
super().tear_down()
def post_construct(self):
hooks.append("post_construct")
super().post_construct()
assert HookManager(Scene()).render() is False
assert hooks == ["setup", "construct", "tear_down", "post_construct"]
def test_manager_render_handles_rerun_without_finishing_scene(dry_run):
lifecycle: list[str] = []
renderer = Mock()
renderer.num_plays = 3
class RerunScene(Scene):
def construct(self):
raise RerunSceneException
def tear_down(self):
lifecycle.append("tear_down")
scene = RerunScene(renderer)
assert Manager(scene).render() is True
renderer.clear_screen.assert_called_once_with()
assert renderer.num_plays == 0
renderer.scene_finished.assert_not_called()
assert lifecycle == []
def test_manager_render_finalizes_after_early_scene_end(dry_run):
lifecycle: list[str] = []
renderer = Mock()
renderer.num_plays = 0
renderer.scene_finished.side_effect = lambda scene: lifecycle.append(
"post_construct"
)
class EarlyEndScene(Scene):
def construct(self):
raise EndSceneEarlyException
def tear_down(self):
lifecycle.append("tear_down")
scene = EarlyEndScene(renderer)
assert Manager(scene).render() is False
renderer.scene_finished.assert_called_once_with(scene)
assert lifecycle == ["tear_down", "post_construct"]
def test_scene_play_forwards_through_manager(dry_run, monkeypatch):
scene = Scene()
renderer_play = Mock()
file_writer = Mock()
file_writer.subcaptions = []
monkeypatch.setattr(scene.renderer, "play", renderer_play)
scene.renderer.file_writer = file_writer
animation = Wait()
scene.play(animation, run_time=2)
assert isinstance(scene.manager, Manager)
renderer_play.assert_called_once_with(scene, animation, run_time=2)
assert file_writer.subcaptions == []
def test_scene_play_adds_subcaption_with_explicit_duration(dry_run, monkeypatch):
scene = Scene()
file_writer = Mock()
file_writer.subcaptions = []
scene.renderer.file_writer = file_writer
scene.renderer.time = 2.5
renderer_play = Mock(
side_effect=lambda *args, **kwargs: setattr(scene.renderer, "time", 4.5)
)
monkeypatch.setattr(scene.renderer, "play", renderer_play)
animation = Wait()
scene.play(
animation,
run_time=2,
subcaption="Hello",
subcaption_duration=1.25,
subcaption_offset=0.25,
)
renderer_play.assert_called_once_with(scene, animation, run_time=2)
assert file_writer.subcaptions == [
srt.Subtitle(
index=0,
content="Hello",
start=datetime.timedelta(seconds=2.75),
end=datetime.timedelta(seconds=4.0),
)
]
def test_scene_play_preserves_scene_add_subcaption_override(dry_run, monkeypatch):
subcaptions: list[tuple[str, float, float]] = []
class CustomSubcaptionScene(Scene):
def add_subcaption(
self, content: str, duration: float = 1, offset: float = 0
) -> None:
subcaptions.append((content, duration, offset))
scene = CustomSubcaptionScene()
scene.renderer.time = 2.5
renderer_play = Mock(
side_effect=lambda *args, **kwargs: setattr(scene.renderer, "time", 4.5)
)
monkeypatch.setattr(scene.renderer, "play", renderer_play)
scene.play(
Wait(),
subcaption="Hello",
subcaption_duration=1.25,
subcaption_offset=0.25,
)
assert subcaptions == [("Hello", 1.25, -1.75)]
def test_scene_play_uses_animation_duration_for_default_subcaption_after_skip(
dry_run, monkeypatch
):
scene = Scene()
file_writer = Mock()
file_writer.subcaptions = []
scene.renderer.file_writer = file_writer
scene.renderer.time = 1.0
scene.renderer.skip_animations = True
renderer_play = Mock(
side_effect=lambda *args, **kwargs: setattr(scene.renderer, "time", 3.5)
)
monkeypatch.setattr(scene.renderer, "play", renderer_play)
scene.play(Wait(), subcaption="Hello")
assert file_writer.subcaptions == [
srt.Subtitle(
index=0,
content="Hello",
start=datetime.timedelta(seconds=1.0),
end=datetime.timedelta(seconds=3.5),
)
]
def test_scene_play_queues_interactive_calls_without_attaching_manager(
dry_run, monkeypatch
):
scene = Scene()
scene.interactive_mode = True
renderer_play = Mock()
monkeypatch.setattr(scene.renderer, "play", renderer_play)
worker_thread = threading.Thread(name="Worker")
monkeypatch.setattr(threading, "current_thread", lambda: worker_thread)
with tempconfig({"renderer": RendererType.OPENGL}):
scene.play(
Wait(),
run_time=2,
subcaption="Hello",
subcaption_duration=1.25,
subcaption_offset=0.5,
)
assert scene.manager is None
renderer_play.assert_not_called()
queued_call = scene.queue.get_nowait()
assert isinstance(queued_call, SceneInteractRerun)
assert queued_call.sender == "play"
assert queued_call.kwargs == {
"run_time": 2,
"subcaption": "Hello",
"subcaption_duration": 1.25,
"subcaption_offset": 0.5,
}
def test_manager_views_follow_the_scene_renderer(dry_run):
scene = Scene()
manager = Manager(scene)
replacement_renderer = Mock()
replacement_renderer.camera = Mock()
replacement_renderer.file_writer = Mock()
replacement_renderer.time = 1.5
replacement_renderer.num_plays = 2
replacement_renderer.skip_animations = False
scene.renderer = replacement_renderer
assert manager.renderer is replacement_renderer
assert manager.camera is replacement_renderer.camera
assert manager.file_writer is replacement_renderer.file_writer
assert manager.time == 1.5
assert manager.num_plays == 2
assert manager.skip_animations is False
manager.time = 2.5
manager.num_plays = 3
manager.skip_animations = True
assert replacement_renderer.time == 2.5
assert replacement_renderer.num_plays == 3
assert replacement_renderer.skip_animations is True
def test_scene_next_section_delegates_to_manager(dry_run):
scene = Scene()
file_writer = Mock()
scene.renderer.file_writer = file_writer
section_type = "presentation.skip"
scene.next_section("intro", section_type, skip_animations=True)
assert isinstance(scene.manager, Manager)
file_writer.next_section.assert_called_once_with("intro", section_type, True)
def test_scene_add_subcaption_delegates_to_manager(dry_run):
scene = Scene()
file_writer = Mock()
file_writer.subcaptions = []
scene.renderer.file_writer = file_writer
scene.renderer.time = 2.5
scene.add_subcaption("Hello", duration=1.5, offset=0.25)
assert isinstance(scene.manager, Manager)
assert file_writer.subcaptions == [
srt.Subtitle(
index=0,
content="Hello",
start=datetime.timedelta(seconds=2.75),
end=datetime.timedelta(seconds=4.25),
)
]
def test_scene_add_sound_delegates_to_manager_and_honors_skip_state(dry_run):
scene = Scene()
file_writer = Mock()
scene.renderer.file_writer = file_writer
scene.renderer.time = 2.5
scene.add_sound("bell.wav", time_offset=0.25, gain=-3, marker="test")
assert isinstance(scene.manager, Manager)
file_writer.add_sound.assert_called_once_with("bell.wav", 2.75, -3, marker="test")
file_writer.add_sound.reset_mock()
scene.renderer.skip_animations = True
scene.add_sound("skipped.wav")
file_writer.add_sound.assert_not_called()