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

manim/scene/scene.py

@@ -2,6 +2,10 @@
 
 from __future__ import annotations
 
+from manim.utils.parameter_parsing import flatten_iterable_parameters
+
+from ..mobject.mobject import _AnimationBuilder
+
 __all__ = ["Scene"]
 
 import copy
@@ -11,9 +15,9 @@ import platform
 import random
 import threading
 import time
-import types
+from dataclasses import dataclass
+from pathlib import Path
 from queue import Queue
-from typing import Callable
 
 import srt
 
@@ -23,13 +27,21 @@ try:
     import dearpygui.dearpygui as dpg
 
     dearpygui_imported = True
+    dpg.create_context()
+    window = dpg.generate_uuid()
 except ImportError:
     dearpygui_imported = False
+
+from collections.abc import Callable, Iterable, Sequence
+from typing import TYPE_CHECKING, Any, Union
+
 import numpy as np
 from tqdm import tqdm
-from watchdog.events import FileSystemEventHandler
+from watchdog.events import DirModifiedEvent, FileModifiedEvent, FileSystemEventHandler
 from watchdog.observers import Observer
 
+from manim import __version__
+from manim.data_structures import MethodWithArgs
 from manim.mobject.mobject import Mobject
 from manim.mobject.opengl.opengl_mobject import OpenGLPoint
 
@@ -37,9 +49,8 @@ from .. import config, logger
 from ..animation.animation import Animation, Wait, prepare_animation
 from ..camera.camera import Camera
 from ..constants import *
-from ..gui.gui import configure_pygui
 from ..renderer.cairo_renderer import CairoRenderer
-from ..renderer.opengl_renderer import OpenGLRenderer
+from ..renderer.opengl_renderer import OpenGLCamera, OpenGLMobject, OpenGLRenderer
 from ..renderer.shader import Object3D
 from ..utils import opengl, space_ops
 from ..utils.exceptions import EndSceneEarlyException, RerunSceneException
@@ -47,17 +58,83 @@ from ..utils.family import extract_mobject_family_members
 from ..utils.family_ops import restructure_list_to_exclude_certain_family_members
 from ..utils.file_ops import open_media_file
 from ..utils.iterables import list_difference_update, list_update
+from ..utils.module_ops import scene_classes_from_file
+
+if TYPE_CHECKING:
+    from types import FrameType
+
+    from typing_extensions import Self, TypeAlias
+
+    from manim.typing import Point3D
+
+    SceneInteractAction: TypeAlias = Union[
+        MethodWithArgs, "SceneInteractContinue", "SceneInteractRerun"
+    ]
+    """The SceneInteractAction type alias is used for elements in the queue
+    used by :meth:`.Scene.interact()`.
+
+    The elements can be one of the following three:
+
+    - a :class:`~.MethodWithArgs` object, which represents a :class:`Scene`
+      method to be called along with its args and kwargs,
+    - a :class:`~.SceneInteractContinue` object, indicating that the scene
+      interaction is over and the scene will continue rendering after that, or
+    - a :class:`~.SceneInteractRerun` object, indicating that the scene should
+      render again.
+    """
+
+
+@dataclass
+class SceneInteractContinue:
+    """Object which, when encountered in :meth:`.Scene.interact`, triggers
+    the end of the scene interaction, continuing with the rest of the
+    animations, if any. This object can be queued in :attr:`.Scene.queue`
+    for later use in :meth:`.Scene.interact`.
+
+    Attributes
+    ----------
+    sender : str
+        The name of the entity which issued the end of the scene interaction,
+        such as ``"gui"`` or ``"keyboard"``.
+    """
+
+    __slots__ = ["sender"]
+
+    sender: str
+
+
+class SceneInteractRerun:
+    """Object which, when encountered in :meth:`.Scene.interact`, triggers
+    the rerun of the scene. This object can be queued in :attr:`.Scene.queue`
+    for later use in :meth:`.Scene.interact`.
+
+    Attributes
+    ----------
+    sender : str
+        The name of the entity which issued the rerun of the scene, such as
+        ``"gui"``, ``"keyboard"``, ``"play"`` or ``"file"``.
+    kwargs : dict[str, Any]
+        Additional keyword arguments when rerunning the scene. Currently,
+        only ``"from_animation_number"`` is being used, which determines the
+        animation from which to start rerunning the scene.
+    """
+
+    __slots__ = ["sender", "kwargs"]
+
+    def __init__(self, sender: str, **kwargs: Any) -> None:
+        self.sender = sender
+        self.kwargs = kwargs
 
 
 class RerunSceneHandler(FileSystemEventHandler):
     """A class to handle rerunning a Scene after the input file is modified."""
 
-    def __init__(self, queue):
+    def __init__(self, queue: Queue[SceneInteractAction]) -> None:
         super().__init__()
         self.queue = queue
 
-    def on_modified(self, event):
-        self.queue.put(("rerun_file", [], {}))
+    def on_modified(self, event: DirModifiedEvent | FileModifiedEvent) -> None:
+        self.queue.put(SceneInteractRerun("file"))
 
 
 class Scene:
@@ -93,35 +170,33 @@ class Scene:
 
     def __init__(
         self,
-        renderer=None,
-        camera_class=Camera,
-        always_update_mobjects=False,
-        random_seed=None,
-        skip_animations=False,
-    ):
+        renderer: CairoRenderer | OpenGLRenderer | None = None,
+        camera_class: type[Camera] = Camera,
+        always_update_mobjects: bool = False,
+        random_seed: int | None = None,
+        skip_animations: bool = False,
+    ) -> None:
         self.camera_class = camera_class
         self.always_update_mobjects = always_update_mobjects
         self.random_seed = random_seed
         self.skip_animations = skip_animations
 
-        self.animations = None
-        self.stop_condition = None
-        self.moving_mobjects = []
-        self.static_mobjects = []
-        self.time_progression = None
-        self.duration = None
-        self.last_t = None
-        self.queue = Queue()
+        self.animations: list[Animation] | None = None
+        self.stop_condition: Callable[[], bool] | None = None
+        self.moving_mobjects: list[Mobject] = []
+        self.static_mobjects: list[Mobject] = []
+        self.time_progression: tqdm[float] | None = None
+        self.duration: float = 0.0
+        self.last_t = 0.0
+        self.queue: Queue[SceneInteractAction] = Queue()
         self.skip_animation_preview = False
-        self.meshes = []
+        self.meshes: list[Object3D] = []
         self.camera_target = ORIGIN
-        self.widgets = []
+        self.widgets: list[dict[str, Any]] = []
         self.dearpygui_imported = dearpygui_imported
-        self.updaters = []
-        self.point_lights = []
-        self.ambient_light = None
-        self.key_to_function_map = {}
-        self.mouse_press_callbacks = []
+        self.updaters: list[Callable[[float], None]] = []
+        self.key_to_function_map: dict[str, Callable[[], None]] = {}
+        self.mouse_press_callbacks: list[Callable[[], None]] = []
         self.interactive_mode = False
 
         if config.renderer == RendererType.OPENGL:
@@ -132,7 +207,9 @@ class Scene:
                 renderer = OpenGLRenderer()
 
         if renderer is None:
-            self.renderer = CairoRenderer(
+            self.renderer: CairoRenderer | OpenGLRenderer = CairoRenderer(
+                # TODO: Is it a suitable approach to make an instance of
+                # the self.camera_class here?
                 camera_class=self.camera_class,
                 skip_animations=self.skip_animations,
             )
@@ -140,18 +217,23 @@ class Scene:
             self.renderer = renderer
         self.renderer.init_scene(self)
 
-        self.mobjects = []
+        self.mobjects: list[Mobject] = []
         # TODO, remove need for foreground mobjects
-        self.foreground_mobjects = []
+        self.foreground_mobjects: list[Mobject] = []
         if self.random_seed is not None:
             random.seed(self.random_seed)
             np.random.seed(self.random_seed)
 
     @property
-    def camera(self):
+    def camera(self) -> Camera | OpenGLCamera:
         return self.renderer.camera
 
-    def __deepcopy__(self, clone_from_id):
+    @property
+    def time(self) -> float:
+        """The time since the start of the scene."""
+        return self.renderer.time
+
+    def __deepcopy__(self, clone_from_id: dict[int, Any]) -> Scene:
         cls = self.__class__
         result = cls.__new__(cls)
         clone_from_id[id(self)] = result
@@ -161,55 +243,10 @@ class Scene:
             if k == "camera_class":
                 setattr(result, k, v)
             setattr(result, k, copy.deepcopy(v, clone_from_id))
-        result.mobject_updater_lists = []
-
-        # Update updaters
-        for mobject in self.mobjects:
-            cloned_updaters = []
-            for updater in mobject.updaters:
-                # Make the cloned updater use the cloned Mobjects as free variables
-                # rather than the original ones. Analyzing function bytecode with the
-                # dis module will help in understanding this.
-                # https://docs.python.org/3/library/dis.html
-                # TODO: Do the same for function calls recursively.
-                free_variable_map = inspect.getclosurevars(updater).nonlocals
-                cloned_co_freevars = []
-                cloned_closure = []
-                for free_variable_name in updater.__code__.co_freevars:
-                    free_variable_value = free_variable_map[free_variable_name]
-
-                    # If the referenced variable has not been cloned, raise.
-                    if id(free_variable_value) not in clone_from_id:
-                        raise Exception(
-                            f"{free_variable_name} is referenced from an updater "
-                            "but is not an attribute of the Scene, which isn't "
-                            "allowed.",
-                        )
-
-                    # Add the cloned object's name to the free variable list.
-                    cloned_co_freevars.append(free_variable_name)
-
-                    # Add a cell containing the cloned object's reference to the
-                    # closure list.
-                    cloned_closure.append(
-                        types.CellType(clone_from_id[id(free_variable_value)]),
-                    )
 
-                cloned_updater = types.FunctionType(
-                    updater.__code__.replace(co_freevars=tuple(cloned_co_freevars)),
-                    updater.__globals__,
-                    updater.__name__,
-                    updater.__defaults__,
-                    tuple(cloned_closure),
-                )
-                cloned_updaters.append(cloned_updater)
-            mobject_clone = clone_from_id[id(mobject)]
-            mobject_clone.updaters = cloned_updaters
-            if len(cloned_updaters) > 0:
-                result.mobject_updater_lists.append((mobject_clone, cloned_updaters))
         return result
 
-    def render(self, preview: bool = False):
+    def render(self, preview: bool = False) -> bool:
         """
         Renders this Scene.
 
@@ -223,9 +260,10 @@ class Scene:
             self.construct()
         except EndSceneEarlyException:
             pass
-        except RerunSceneException as e:
+        except RerunSceneException:
             self.remove(*self.mobjects)
-            self.renderer.clear_screen()
+            # TODO: The CairoRenderer does not have the method clear_screen()
+            self.renderer.clear_screen()  # type: ignore[union-attr]
             self.renderer.num_plays = 0
             return True
         self.tear_down()
@@ -249,7 +287,9 @@ class Scene:
         if config["preview"] or config["show_in_file_browser"]:
             open_media_file(self.renderer.file_writer)
 
-    def setup(self):
+        return False
+
+    def setup(self) -> None:
         """
         This is meant to be implemented by any scenes which
         are commonly subclassed, and have some common setup
@@ -257,7 +297,7 @@ class Scene:
         """
         pass
 
-    def tear_down(self):
+    def tear_down(self) -> None:
         """
         This is meant to be implemented by any scenes which
         are commonly subclassed, and have some common method
@@ -265,7 +305,7 @@ class Scene:
         """
         pass
 
-    def construct(self):
+    def construct(self) -> None:
         """Add content to the Scene.
 
         From within :meth:`Scene.construct`, display mobjects on screen by calling
@@ -281,7 +321,7 @@ class Scene:
         Examples
         --------
         A typical manim script includes a class derived from :class:`Scene` with an
-        overridden :meth:`Scene.contruct` method:
+        overridden :meth:`Scene.construct` method:
 
         .. code-block:: python
 
@@ -301,19 +341,19 @@ class Scene:
     def next_section(
         self,
         name: str = "unnamed",
-        type: str = DefaultSectionType.NORMAL,
+        section_type: str = DefaultSectionType.NORMAL,
         skip_animations: bool = False,
     ) -> None:
         """Create separation here; the last section gets finished and a new one gets created.
         ``skip_animations`` skips the rendering of all animations in this section.
         Refer to :doc:`the documentation</tutorials/output_and_config>` on how to use sections.
         """
-        self.renderer.file_writer.next_section(name, type, skip_animations)
+        self.renderer.file_writer.next_section(name, section_type, skip_animations)
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.__class__.__name__
 
-    def get_attrs(self, *keys: str):
+    def get_attrs(self, *keys: str) -> list[Any]:
         """
         Gets attributes of a scene given the attribute's identifier/name.
 
@@ -329,7 +369,7 @@ class Scene:
         """
         return [getattr(self, key) for key in keys]
 
-    def update_mobjects(self, dt: float):
+    def update_mobjects(self, dt: float) -> None:
         """
         Begins updating all mobjects in the Scene.
 
@@ -338,15 +378,15 @@ class Scene:
         dt
             Change in time between updates. Defaults (mostly) to 1/frames_per_second
         """
-        for mobject in self.mobjects:
-            mobject.update(dt)
+        for mobj in self.mobjects:
+            mobj.update(dt)
 
-    def update_meshes(self, dt):
+    def update_meshes(self, dt: float) -> None:
         for obj in self.meshes:
             for mesh in obj.get_family():
                 mesh.update(dt)
 
-    def update_self(self, dt: float):
+    def update_self(self, dt: float) -> None:
         """Run all scene updater functions.
 
         Among all types of update functions (mobject updaters, mesh updaters,
@@ -378,22 +418,23 @@ class Scene:
 
         This is only called when a single Wait animation is played.
         """
+        assert self.animations is not None
         wait_animation = self.animations[0]
+        assert isinstance(wait_animation, Wait)
         if wait_animation.is_static_wait is None:
             should_update = (
                 self.always_update_mobjects
                 or self.updaters
+                or wait_animation.stop_condition is not None
                 or any(
-                    [
-                        mob.has_time_based_updater()
-                        for mob in self.get_mobject_family_members()
-                    ],
+                    mob.has_time_based_updater()
+                    for mob in self.get_mobject_family_members()
                 )
             )
             wait_animation.is_static_wait = not should_update
         return not wait_animation.is_static_wait
 
-    def get_top_level_mobjects(self):
+    def get_top_level_mobjects(self) -> list[Mobject]:
         """
         Returns all mobjects which are not submobjects.
 
@@ -406,13 +447,13 @@ class Scene:
         # of another mobject from the scene
         families = [m.get_family() for m in self.mobjects]
 
-        def is_top_level(mobject):
+        def is_top_level(mobject: Mobject) -> bool:
             num_families = sum((mobject in family) for family in families)
             return num_families == 1
 
         return list(filter(is_top_level, self.mobjects))
 
-    def get_mobject_family_members(self):
+    def get_mobject_family_members(self) -> list[Mobject]:
         """
         Returns list of family-members of all mobjects in scene.
         If a Circle() and a VGroup(Rectangle(),Triangle()) were added,
@@ -429,13 +470,14 @@ class Scene:
             for mob in self.mobjects:
                 family_members.extend(mob.get_family())
             return family_members
-        elif config.renderer == RendererType.CAIRO:
+        else:
+            assert config.renderer == RendererType.CAIRO
             return extract_mobject_family_members(
                 self.mobjects,
                 use_z_index=self.renderer.camera.use_z_index,
             )
 
-    def add(self, *mobjects: Mobject):
+    def add(self, *mobjects: Mobject | OpenGLMobject) -> Self:
         """
         Mobjects will be displayed, from background to
         foreground in the order with which they are added.
@@ -453,29 +495,33 @@ class Scene:
         """
         if config.renderer == RendererType.OPENGL:
             new_mobjects = []
-            new_meshes = []
+            new_meshes: list[Object3D] = []
             for mobject_or_mesh in mobjects:
                 if isinstance(mobject_or_mesh, Object3D):
                     new_meshes.append(mobject_or_mesh)
                 else:
                     new_mobjects.append(mobject_or_mesh)
-            self.remove(*new_mobjects)
-            self.mobjects += new_mobjects
-            self.remove(*new_meshes)
+            self.remove(*new_mobjects)  # type: ignore[arg-type]
+            self.mobjects += new_mobjects  # type: ignore[arg-type]
+            self.remove(*new_meshes)  # type: ignore[arg-type]
             self.meshes += new_meshes
-        elif config.renderer == RendererType.CAIRO:
-            mobjects = [*mobjects, *self.foreground_mobjects]
-            self.restructure_mobjects(to_remove=mobjects)
-            self.mobjects += mobjects
+        else:
+            assert config.renderer == RendererType.CAIRO
+            new_and_foreground_mobjects: list[Mobject] = [
+                *mobjects,  # type: ignore[list-item]
+                *self.foreground_mobjects,
+            ]
+            self.restructure_mobjects(to_remove=new_and_foreground_mobjects)
+            self.mobjects += new_and_foreground_mobjects
             if self.moving_mobjects:
                 self.restructure_mobjects(
-                    to_remove=mobjects,
+                    to_remove=new_and_foreground_mobjects,
                     mobject_list_name="moving_mobjects",
                 )
-                self.moving_mobjects += mobjects
+                self.moving_mobjects += new_and_foreground_mobjects
         return self
 
-    def add_mobjects_from_animations(self, animations):
+    def add_mobjects_from_animations(self, animations: list[Animation]) -> None:
         curr_mobjects = self.get_mobject_family_members()
         for animation in animations:
             if animation.is_introducer():
@@ -485,9 +531,9 @@ class Scene:
             mob = animation.mobject
             if mob is not None and mob not in curr_mobjects:
                 self.add(mob)
-                curr_mobjects += mob.get_family()
+                curr_mobjects += mob.get_family()  # type: ignore[arg-type]
 
-    def remove(self, *mobjects: Mobject):
+    def remove(self, *mobjects: Mobject) -> Self:
         """
         Removes mobjects in the passed list of mobjects
         from the scene and the foreground, by removing them
@@ -500,7 +546,8 @@ class Scene:
         """
         if config.renderer == RendererType.OPENGL:
             mobjects_to_remove = []
-            meshes_to_remove = set()
+            meshes_to_remove: set[Object3D] = set()
+            mobject_or_mesh: Mobject
             for mobject_or_mesh in mobjects:
                 if isinstance(mobject_or_mesh, Object3D):
                     meshes_to_remove.add(mobject_or_mesh)
@@ -510,15 +557,80 @@ class Scene:
                 self.mobjects,
                 mobjects_to_remove,
             )
+
+            def lambda_function(mesh: Object3D) -> bool:
+                return mesh not in set(meshes_to_remove)
+
             self.meshes = list(
-                filter(lambda mesh: mesh not in set(meshes_to_remove), self.meshes),
+                filter(lambda_function, self.meshes),
             )
             return self
-        elif config.renderer == RendererType.CAIRO:
+        else:
+            assert config.renderer == RendererType.CAIRO
             for list_name in "mobjects", "foreground_mobjects":
                 self.restructure_mobjects(mobjects, list_name, False)
             return self
 
+    def replace(self, old_mobject: Mobject, new_mobject: Mobject) -> None:
+        """Replace one mobject in the scene with another, preserving draw order.
+
+        If ``old_mobject`` is a submobject of some other Mobject (e.g. a
+        :class:`.Group`), the new_mobject will replace it inside the group,
+        without otherwise changing the parent mobject.
+
+        Parameters
+        ----------
+        old_mobject
+            The mobject to be replaced. Must be present in the scene.
+        new_mobject
+            A mobject which must not already be in the scene.
+
+        """
+        if old_mobject is None or new_mobject is None:
+            raise ValueError("Specified mobjects cannot be None")
+
+        def replace_in_list(
+            mobj_list: list[Mobject], old_m: Mobject, new_m: Mobject
+        ) -> bool:
+            # Avoid duplicate references to the same object in self.mobjects
+            if new_m in mobj_list:
+                if old_m is new_m:
+                    # In this case, one could say that the old Mobject was already found.
+                    # No replacement is needed, since old_m is new_m, so no action is required.
+                    # This might be unexpected, so raise a warning.
+                    logger.warning(
+                        f"Attempted to replace {type(old_m).__name__} "
+                        "with itself in Scene.mobjects."
+                    )
+                    return True
+                mobj_list.remove(new_m)
+
+            # We use breadth-first search because some Mobjects get very deep and
+            # we expect top-level elements to be the most common targets for replace.
+            for i in range(0, len(mobj_list)):
+                # Is this the old mobject?
+                if mobj_list[i] == old_m:
+                    # If so, write the new object to the same spot and stop looking.
+                    mobj_list[i] = new_m
+                    return True
+            # Now check all the children of all these mobs.
+            for mob in mobj_list:  # noqa: SIM110
+                if replace_in_list(mob.submobjects, old_m, new_m):
+                    # If we found it in a submobject, stop looking.
+                    return True
+            # If we did not find the mobject in the mobject list or any submobjects,
+            # (or the list was empty), indicate we did not make the replacement.
+            return False
+
+        # Make use of short-circuiting conditionals to check mobjects and then
+        # foreground_mobjects
+        replaced = replace_in_list(
+            self.mobjects, old_mobject, new_mobject
+        ) or replace_in_list(self.foreground_mobjects, old_mobject, new_mobject)
+
+        if not replaced:
+            raise ValueError(f"Could not find {old_mobject} in scene")
+
     def add_updater(self, func: Callable[[float], None]) -> None:
         """Add an update function to the scene.
 
@@ -567,10 +679,10 @@ class Scene:
 
     def restructure_mobjects(
         self,
-        to_remove: Mobject,
+        to_remove: Sequence[Mobject],
         mobject_list_name: str = "mobjects",
         extract_families: bool = True,
-    ):
+    ) -> Scene:
         """
         tl:wr
             If your scene has a Group(), and you removed a mobject from the Group,
@@ -608,7 +720,9 @@ class Scene:
         setattr(self, mobject_list_name, new_list)
         return self
 
-    def get_restructured_mobject_list(self, mobjects: list, to_remove: list):
+    def get_restructured_mobject_list(
+        self, mobjects: Iterable[Mobject], to_remove: Iterable[Mobject]
+    ) -> list[Mobject]:
         """
         Given a list of mobjects and a list of mobjects to be removed, this
         filters out the removable mobjects from the list of mobjects.
@@ -627,10 +741,11 @@ class Scene:
         list
             The list of mobjects with the mobjects to remove removed.
         """
+        new_mobjects: list[Mobject] = []
 
-        new_mobjects = []
-
-        def add_safe_mobjects_from_list(list_to_examine, set_to_remove):
+        def add_safe_mobjects_from_list(
+            list_to_examine: Iterable[Mobject], set_to_remove: set[Mobject]
+        ) -> None:
             for mob in list_to_examine:
                 if mob in set_to_remove:
                     continue
@@ -644,7 +759,7 @@ class Scene:
         return new_mobjects
 
     # TODO, remove this, and calls to this
-    def add_foreground_mobjects(self, *mobjects: Mobject):
+    def add_foreground_mobjects(self, *mobjects: Mobject) -> Scene:
         """
         Adds mobjects to the foreground, and internally to the list
         foreground_mobjects, and mobjects.
@@ -663,7 +778,7 @@ class Scene:
         self.add(*mobjects)
         return self
 
-    def add_foreground_mobject(self, mobject: Mobject):
+    def add_foreground_mobject(self, mobject: Mobject) -> Scene:
         """
         Adds a single mobject to the foreground, and internally to the list
         foreground_mobjects, and mobjects.
@@ -680,7 +795,7 @@ class Scene:
         """
         return self.add_foreground_mobjects(mobject)
 
-    def remove_foreground_mobjects(self, *to_remove: Mobject):
+    def remove_foreground_mobjects(self, *to_remove: Mobject) -> Scene:
         """
         Removes mobjects from the foreground, and internally from the list
         foreground_mobjects.
@@ -698,7 +813,7 @@ class Scene:
         self.restructure_mobjects(to_remove, "foreground_mobjects")
         return self
 
-    def remove_foreground_mobject(self, mobject: Mobject):
+    def remove_foreground_mobject(self, mobject: Mobject) -> Scene:
         """
         Removes a single mobject from the foreground, and internally from the list
         foreground_mobjects.
@@ -715,7 +830,7 @@ class Scene:
         """
         return self.remove_foreground_mobjects(mobject)
 
-    def bring_to_front(self, *mobjects: Mobject):
+    def bring_to_front(self, *mobjects: Mobject) -> Scene:
         """
         Adds the passed mobjects to the scene again,
         pushing them to he front of the scene.
@@ -734,7 +849,7 @@ class Scene:
         self.add(*mobjects)
         return self
 
-    def bring_to_back(self, *mobjects: Mobject):
+    def bring_to_back(self, *mobjects: Mobject) -> Scene:
         """
         Removes the mobject from the scene and
         adds them to the back of the scene.
@@ -754,7 +869,7 @@ class Scene:
         self.mobjects = list(mobjects) + self.mobjects
         return self
 
-    def clear(self):
+    def clear(self) -> Self:
         """
         Removes all mobjects present in self.mobjects
         and self.foreground_mobjects from the scene.
@@ -770,7 +885,7 @@ class Scene:
         self.foreground_mobjects = []
         return self
 
-    def get_moving_mobjects(self, *animations: Animation):
+    def get_moving_mobjects(self, *animations: Animation) -> list[Mobject]:
         """
         Gets all moving mobjects in the passed animation(s).
 
@@ -801,7 +916,9 @@ class Scene:
                 return mobjects[i:]
         return []
 
-    def get_moving_and_static_mobjects(self, animations):
+    def get_moving_and_static_mobjects(
+        self, animations: Iterable[Animation]
+    ) -> tuple[list[Mobject], list[Mobject]]:
         all_mobjects = list_update(self.mobjects, self.foreground_mobjects)
         all_mobject_families = extract_mobject_family_members(
             all_mobjects,
@@ -819,7 +936,11 @@ class Scene:
         )
         return all_moving_mobject_families, static_mobjects
 
-    def compile_animations(self, *args: Animation, **kwargs):
+    def compile_animations(
+        self,
+        *args: Animation | Mobject | _AnimationBuilder,
+        **kwargs: Any,
+    ) -> list[Animation]:
         """
         Creates _MethodAnimations from any _AnimationBuilders and updates animation
         kwargs with kwargs passed to play().
@@ -837,19 +958,21 @@ class Scene:
             Animations to be played.
         """
         animations = []
-        for arg in args:
+        arg_anims = flatten_iterable_parameters(args)
+        # Allow passing a generator to self.play instead of comma separated arguments
+        for arg in arg_anims:
             try:
-                animations.append(prepare_animation(arg))
-            except TypeError:
+                animations.append(prepare_animation(arg))  # type: ignore[arg-type]
+            except TypeError as e:
                 if inspect.ismethod(arg):
                     raise TypeError(
                         "Passing Mobject methods to Scene.play is no longer"
                         " supported. Use Mobject.animate instead.",
-                    )
+                    ) from e
                 else:
                     raise TypeError(
                         f"Unexpected argument {arg} passed to Scene.play().",
-                    )
+                    ) from e
 
         for animation in animations:
             for k, v in kwargs.items():
@@ -859,7 +982,7 @@ class Scene:
 
     def _get_animation_time_progression(
         self, animations: list[Animation], duration: float
-    ):
+    ) -> tqdm[float]:
         """
         You will hardly use this when making your own animations.
         This method is for Manim's internal use.
@@ -912,10 +1035,10 @@ class Scene:
     def get_time_progression(
         self,
         run_time: float,
-        description,
+        description: str,
         n_iterations: int | None = None,
         override_skip_animations: bool = False,
-    ):
+    ) -> tqdm[float]:
         """
         You will hardly use this when making your own animations.
         This method is for Manim's internal use.
@@ -943,7 +1066,7 @@ class Scene:
             The CommandLine Progress Bar.
         """
         if self.renderer.skip_animations and not override_skip_animations:
-            times = [run_time]
+            times: Iterable[float] = [run_time]
         else:
             step = 1 / config["frame_rate"]
             times = np.arange(0, run_time, step)
@@ -957,7 +1080,36 @@ class Scene:
         )
         return time_progression
 
-    def get_run_time(self, animations: list[Animation]):
+    @classmethod
+    def validate_run_time(
+        cls,
+        run_time: float,
+        method: Callable[[Any], Any],
+        parameter_name: str = "run_time",
+    ) -> float:
+        method_name = f"{cls.__name__}.{method.__name__}()"
+        if run_time <= 0:
+            raise ValueError(
+                f"{method_name} has a {parameter_name} of "
+                f"{run_time:g} <= 0 seconds which Manim cannot render. "
+                f"The {parameter_name} must be a positive number."
+            )
+
+        # config.frame_rate holds the number of frames per second
+        fps = config.frame_rate
+        seconds_per_frame = 1 / fps
+        if run_time < seconds_per_frame:
+            logger.warning(
+                f"The original {parameter_name} of {method_name}, "
+                f"{run_time:g} seconds, is too short for the current frame "
+                f"rate of {fps:g} FPS. Rendering with the shortest possible "
+                f"{parameter_name} of {seconds_per_frame:g} seconds instead."
+            )
+            run_time = seconds_per_frame
+
+        return run_time
+
+    def get_run_time(self, animations: list[Animation]) -> float:
         """
         Gets the total run time for a list of animations.
 
@@ -972,24 +1124,18 @@ class Scene:
         float
             The total ``run_time`` of all of the animations in the list.
         """
-
-        if len(animations) == 1 and isinstance(animations[0], Wait):
-            if animations[0].stop_condition is not None:
-                return 0
-            else:
-                return animations[0].duration
-
-        else:
-            return np.max([animation.run_time for animation in animations])
+        run_time = max(animation.run_time for animation in animations)
+        run_time = self.validate_run_time(run_time, self.play, "total run_time")
+        return run_time
 
     def play(
         self,
-        *args,
-        subcaption=None,
-        subcaption_duration=None,
-        subcaption_offset=0,
-        **kwargs,
-    ):
+        *args: Animation | Mobject | _AnimationBuilder,
+        subcaption: str | None = None,
+        subcaption_duration: float | None = None,
+        subcaption_offset: float = 0,
+        **kwargs: Any,
+    ) -> None:
         r"""Plays an animation in this scene.
 
         Parameters
@@ -1011,8 +1157,13 @@ class Scene:
             All other keywords are passed to the renderer.
 
         """
-        # Make sure this is running on the main thread
-        if threading.current_thread().name != "MainThread":
+        # If we are in interactive embedded mode, make sure this is running on the main thread (required for OpenGL)
+        if (
+            self.interactive_mode
+            and config.renderer == RendererType.OPENGL
+            and threading.current_thread().name != "MainThread"
+        ):
+            # TODO: are these actually being used?
             kwargs.update(
                 {
                     "subcaption": subcaption,
@@ -1020,24 +1171,18 @@ class Scene:
                     "subcaption_offset": subcaption_offset,
                 }
             )
-            self.queue.put(
-                (
-                    "play",
-                    args,
-                    kwargs,
-                )
-            )
+            self.queue.put(SceneInteractRerun("play", **kwargs))
             return
 
-        start_time = self.renderer.time
+        start_time = self.time
         self.renderer.play(self, *args, **kwargs)
-        run_time = self.renderer.time - start_time
+        run_time = self.time - start_time
         if subcaption:
             if subcaption_duration is None:
                 subcaption_duration = run_time
             # The start of the subcaption needs to be offset by the
             # run_time of the animation because it is added after
-            # the animation has already been played (and Scene.renderer.time
+            # the animation has already been played (and Scene.time
             # has already been updated).
             self.add_subcaption(
                 content=subcaption,
@@ -1050,7 +1195,7 @@ class Scene:
         duration: float = DEFAULT_WAIT_TIME,
         stop_condition: Callable[[], bool] | None = None,
         frozen_frame: bool | None = None,
-    ):
+    ) -> None:
         """Plays a "no operation" animation.
 
         Parameters
@@ -1060,7 +1205,8 @@ class Scene:
         stop_condition
             A function without positional arguments that is evaluated every time
             a frame is rendered. The animation only stops when the return value
-            of the function is truthy. Overrides any value passed to ``duration``.
+            of the function is truthy, or when the time specified in ``duration``
+            passes.
         frozen_frame
             If True, updater functions are not evaluated, and the animation outputs
             a frozen frame. If False, updater functions are called and frames
@@ -1071,6 +1217,7 @@ class Scene:
         --------
         :class:`.Wait`, :meth:`.should_mobjects_update`
         """
+        duration = self.validate_run_time(duration, self.wait, "duration")
         self.play(
             Wait(
                 run_time=duration,
@@ -1079,7 +1226,7 @@ class Scene:
             )
         )
 
-    def pause(self, duration: float = DEFAULT_WAIT_TIME):
+    def pause(self, duration: float = DEFAULT_WAIT_TIME) -> None:
         """Pauses the scene (i.e., displays a frozen frame).
 
         This is an alias for :meth:`.wait` with ``frozen_frame``
@@ -1094,25 +1241,30 @@ class Scene:
         --------
         :meth:`.wait`, :class:`.Wait`
         """
+        duration = self.validate_run_time(duration, self.pause, "duration")
         self.wait(duration=duration, frozen_frame=True)
 
-    def wait_until(self, stop_condition: Callable[[], bool], max_time: float = 60):
-        """
-        Like a wrapper for wait().
-        You pass a function that determines whether to continue waiting,
-        and a max wait time if that is never fulfilled.
+    def wait_until(
+        self, stop_condition: Callable[[], bool], max_time: float = 60
+    ) -> None:
+        """Wait until a condition is satisfied, up to a given maximum duration.
 
         Parameters
         ----------
         stop_condition
-            The function whose boolean return value determines whether to continue waiting
-
+            A function with no arguments that determines whether or not the
+            scene should keep waiting.
         max_time
-            The maximum wait time in seconds, if the stop_condition is never fulfilled.
+            The maximum wait time in seconds.
         """
+        max_time = self.validate_run_time(max_time, self.wait_until, "max_time")
         self.wait(max_time, stop_condition=stop_condition)
 
-    def compile_animation_data(self, *animations: Animation, **play_kwargs):
+    def compile_animation_data(
+        self,
+        *animations: Animation | Mobject | _AnimationBuilder,
+        **play_kwargs: Any,
+    ) -> Self | None:
         """Given a list of animations, compile the corresponding
         static and moving mobjects, and gather the animation durations.
 
@@ -1144,20 +1296,21 @@ class Scene:
         self.moving_mobjects = []
         self.static_mobjects = []
 
+        self.duration = self.get_run_time(self.animations)
         if len(self.animations) == 1 and isinstance(self.animations[0], Wait):
             if self.should_update_mobjects():
                 self.update_mobjects(dt=0)  # Any problems with this?
                 self.stop_condition = self.animations[0].stop_condition
             else:
-                self.duration = self.animations[0].duration
                 # Static image logic when the wait is static is done by the renderer, not here.
                 self.animations[0].is_static_wait = True
                 return None
-        self.duration = self.get_run_time(self.animations)
+
         return self
 
     def begin_animations(self) -> None:
         """Start the animations of the scene."""
+        assert self.animations is not None
         for animation in self.animations:
             animation._setup_scene(self)
             animation.begin()
@@ -1172,13 +1325,14 @@ class Scene:
 
     def is_current_animation_frozen_frame(self) -> bool:
         """Returns whether the current animation produces a static frame (generally a Wait)."""
+        assert self.animations is not None
         return (
             isinstance(self.animations[0], Wait)
             and len(self.animations) == 1
             and self.animations[0].is_static_wait
         )
 
-    def play_internal(self, skip_rendering: bool = False):
+    def play_internal(self, skip_rendering: bool = False) -> None:
         """
         This method is used to prep the animations for rendering,
         apply the arguments and parameters required to them,
@@ -1189,6 +1343,7 @@ class Scene:
         skip_rendering
             Whether the rendering should be skipped, by default False
         """
+        assert self.animations is not None
         self.duration = self.get_run_time(self.animations)
         self.time_progression = self._get_animation_time_progression(
             self.animations,
@@ -1207,11 +1362,13 @@ class Scene:
             animation.clean_up_from_scene(self)
         if not self.renderer.skip_animations:
             self.update_mobjects(0)
-        self.renderer.static_image = None
+        # TODO: The OpenGLRenderer does not have the property static.image.
+        self.renderer.static_image = None  # type: ignore[union-attr]
         # Closing the progress bar at the end of the play.
         self.time_progression.close()
 
-    def check_interactive_embed_is_valid(self):
+    def check_interactive_embed_is_valid(self) -> bool:
+        assert isinstance(self.renderer, OpenGLRenderer)
         if config["force_window"]:
             return True
         if self.skip_animation_preview:
@@ -1236,48 +1393,64 @@ class Scene:
             return False
         return True
 
-    def interactive_embed(self):
-        """
-        Like embed(), but allows for screen interaction.
-        """
+    def interactive_embed(self) -> None:
+        """Like embed(), but allows for screen interaction."""
+        assert isinstance(self.camera, OpenGLCamera)
+        assert isinstance(self.renderer, OpenGLRenderer)
         if not self.check_interactive_embed_is_valid():
             return
         self.interactive_mode = True
+        from IPython.terminal.embed import InteractiveShellEmbed
 
-        def ipython(shell, namespace):
+        def ipython(shell: InteractiveShellEmbed, namespace: dict[str, Any]) -> None:
             import manim.opengl
 
-            def load_module_into_namespace(module, namespace):
+            def load_module_into_namespace(
+                module: Any, namespace: dict[str, Any]
+            ) -> None:
                 for name in dir(module):
                     namespace[name] = getattr(module, name)
 
             load_module_into_namespace(manim, namespace)
             load_module_into_namespace(manim.opengl, namespace)
 
-            def embedded_rerun(*args, **kwargs):
-                self.queue.put(("rerun_keyboard", args, kwargs))
+            def embedded_rerun(*args: Any, **kwargs: Any) -> None:
+                self.queue.put(SceneInteractRerun("keyboard"))
                 shell.exiter()
 
             namespace["rerun"] = embedded_rerun
 
             shell(local_ns=namespace)
-            self.queue.put(("exit_keyboard", [], {}))
+            self.queue.put(SceneInteractContinue("keyboard"))
 
-        def get_embedded_method(method_name):
-            return lambda *args, **kwargs: self.queue.put((method_name, args, kwargs))
+        def get_embedded_method(method_name: str) -> Callable[..., None]:
+            method = getattr(self, method_name)
 
-        local_namespace = inspect.currentframe().f_back.f_locals
+            def embedded_method(*args: Any, **kwargs: Any) -> None:
+                self.queue.put(MethodWithArgs(method, args, kwargs))
+
+            return embedded_method
+
+        currentframe: FrameType = inspect.currentframe()  # type: ignore[assignment]
+        local_namespace = currentframe.f_back.f_locals  # type: ignore[union-attr]
         for method in ("play", "wait", "add", "remove"):
             embedded_method = get_embedded_method(method)
             # Allow for calling scene methods without prepending 'self.'.
             local_namespace[method] = embedded_method
 
-        from IPython.terminal.embed import InteractiveShellEmbed
+        from sqlite3 import connect
+
+        from IPython.core.getipython import get_ipython
         from traitlets.config import Config
 
         cfg = Config()
         cfg.TerminalInteractiveShell.confirm_exit = False
-        shell = InteractiveShellEmbed(config=cfg)
+        if get_ipython() is None:
+            shell = InteractiveShellEmbed.instance(config=cfg)
+        else:
+            shell = InteractiveShellEmbed(config=cfg)
+        hist = get_ipython().history_manager
+        hist.db = connect(hist.hist_file, check_same_thread=False)
 
         keyboard_thread = threading.Thread(
             target=ipython,
@@ -1291,19 +1464,21 @@ class Scene:
         if self.dearpygui_imported and config["enable_gui"]:
             if not dpg.is_dearpygui_running():
                 gui_thread = threading.Thread(
-                    target=configure_pygui,
-                    args=(self.renderer, self.widgets),
+                    target=self._configure_pygui,
                     kwargs={"update": False},
                 )
                 gui_thread.start()
             else:
-                configure_pygui(self.renderer, self.widgets, update=True)
+                self._configure_pygui(update=True)
 
         self.camera.model_matrix = self.camera.default_model_matrix
 
         self.interact(shell, keyboard_thread)
 
-    def interact(self, shell, keyboard_thread):
+    # from IPython.terminal.embed import InteractiveShellEmbed
+
+    def interact(self, shell: Any, keyboard_thread: threading.Thread) -> None:
+        assert isinstance(self.renderer, OpenGLRenderer)
         event_handler = RerunSceneHandler(self.queue)
         file_observer = Observer()
         file_observer.schedule(event_handler, config["input_file"], recursive=True)
@@ -1314,36 +1489,38 @@ class Scene:
         assert self.queue.qsize() == 0
 
         last_time = time.time()
-        while not (self.renderer.window.is_closing or self.quit_interaction):
+        while not (
+            (self.renderer.window is not None and self.renderer.window.is_closing)
+            or self.quit_interaction
+        ):
             if not self.queue.empty():
-                tup = self.queue.get_nowait()
-                if tup[0].startswith("rerun"):
+                action = self.queue.get_nowait()
+                if isinstance(action, SceneInteractRerun):
                     # Intentionally skip calling join() on the file thread to save time.
-                    if not tup[0].endswith("keyboard"):
+                    if action.sender != "keyboard":
                         if shell.pt_app:
                             shell.pt_app.app.exit(exception=EOFError)
                         file_observer.unschedule_all()
                         raise RerunSceneException
                     keyboard_thread.join()
 
-                    kwargs = tup[2]
-                    if "from_animation_number" in kwargs:
-                        config["from_animation_number"] = kwargs[
+                    if "from_animation_number" in action.kwargs:
+                        config["from_animation_number"] = action.kwargs[
                             "from_animation_number"
                         ]
                     # # TODO: This option only makes sense if interactive_embed() is run at the
                     # # end of a scene by default.
-                    # if "upto_animation_number" in kwargs:
-                    #     config["upto_animation_number"] = kwargs[
+                    # if "upto_animation_number" in action.kwargs:
+                    #     config["upto_animation_number"] = action.kwargs[
                     #         "upto_animation_number"
                     #     ]
 
                     keyboard_thread.join()
                     file_observer.unschedule_all()
                     raise RerunSceneException
-                elif tup[0].startswith("exit"):
+                elif isinstance(action, SceneInteractContinue):
                     # Intentionally skip calling join() on the file thread to save time.
-                    if not tup[0].endswith("keyboard") and shell.pt_app:
+                    if action.sender != "keyboard" and shell.pt_app:
                         shell.pt_app.app.exit(exception=EOFError)
                     keyboard_thread.join()
                     # Remove exit_keyboard from the queue if necessary.
@@ -1352,8 +1529,7 @@ class Scene:
                     keyboard_thread_needs_join = False
                     break
                 else:
-                    method, args, kwargs = tup
-                    getattr(self, method)(*args, **kwargs)
+                    action.method(*action.args, **action.kwargs)
             else:
                 self.renderer.animation_start_time = 0
                 dt = time.time() - last_time
@@ -1377,10 +1553,11 @@ class Scene:
         if self.dearpygui_imported and config["enable_gui"]:
             dpg.stop_dearpygui()
 
-        if self.renderer.window.is_closing:
+        if self.renderer.window is not None and self.renderer.window.is_closing:
             self.renderer.window.destroy()
 
-    def embed(self):
+    def embed(self) -> None:
+        assert isinstance(self.renderer, OpenGLRenderer)
         if not config["preview"]:
             logger.warning("Called embed() while no preview window is available.")
             return
@@ -1404,7 +1581,9 @@ class Scene:
 
         # Use the locals of the caller as the local namespace
         # once embedded, and add a few custom shortcuts.
-        local_ns = inspect.currentframe().f_back.f_locals
+        current_frame = inspect.currentframe()
+        assert isinstance(current_frame, FrameType)
+        local_ns = current_frame.f_back.f_locals  # type: ignore[union-attr]
         # local_ns["touch"] = self.interact
         for method in (
             "play",
@@ -1422,9 +1601,77 @@ class Scene:
         # End scene when exiting an embed.
         raise Exception("Exiting scene.")
 
-    def update_to_time(self, t):
+    def _configure_pygui(self, update: bool = True) -> None:
+        if not self.dearpygui_imported:
+            raise RuntimeError("Attempted to use DearPyGUI when it isn't imported.")
+        if update:
+            dpg.delete_item(window)
+        else:
+            dpg.create_viewport()
+            dpg.setup_dearpygui()
+            dpg.show_viewport()
+
+        dpg.set_viewport_title(title=f"Manim Community v{__version__}")
+        dpg.set_viewport_width(1015)
+        dpg.set_viewport_height(540)
+
+        def rerun_callback(sender: Any, data: Any) -> None:
+            self.queue.put(SceneInteractRerun("gui"))
+
+        def continue_callback(sender: Any, data: Any) -> None:
+            self.queue.put(SceneInteractContinue("gui"))
+
+        def scene_selection_callback(sender: Any, data: Any) -> None:
+            config["scene_names"] = (dpg.get_value(sender),)
+            self.queue.put(SceneInteractRerun("gui"))
+
+        scene_classes = scene_classes_from_file(
+            Path(config["input_file"]), full_list=True
+        )  # type: ignore[call-overload]
+        scene_names = [scene_class.__name__ for scene_class in scene_classes]
+
+        with dpg.window(
+            id=window,
+            label="Manim GUI",
+            pos=[config["gui_location"][0], config["gui_location"][1]],
+            width=1000,
+            height=500,
+        ):
+            dpg.set_global_font_scale(2)
+            dpg.add_button(label="Rerun", callback=rerun_callback)
+            dpg.add_button(label="Continue", callback=continue_callback)
+            dpg.add_combo(
+                label="Selected scene",
+                items=scene_names,
+                callback=scene_selection_callback,
+                default_value=config["scene_names"][0],
+            )
+            dpg.add_separator()
+            if len(self.widgets) != 0:
+                with dpg.collapsing_header(
+                    label=f"{config['scene_names'][0]} widgets",
+                    default_open=True,
+                ):
+                    for widget_config in self.widgets:
+                        widget_config_copy = widget_config.copy()
+                        name = widget_config_copy["name"]
+                        widget = widget_config_copy["widget"]
+                        if widget != "separator":
+                            del widget_config_copy["name"]
+                            del widget_config_copy["widget"]
+                            getattr(dpg, f"add_{widget}")(
+                                label=name, **widget_config_copy
+                            )
+                        else:
+                            dpg.add_separator()
+
+        if not update:
+            dpg.start_dearpygui()
+
+    def update_to_time(self, t: float) -> None:
         dt = t - self.last_t
         self.last_t = t
+        assert self.animations is not None
         for animation in self.animations:
             animation.update_mobjects(dt)
             alpha = t / animation.run_time
@@ -1439,7 +1686,7 @@ class Scene:
         r"""Adds an entry in the corresponding subcaption file
         at the current time stamp.
 
-        The current time stamp is obtained from ``Scene.renderer.time``.
+        The current time stamp is obtained from ``Scene.time``.
 
         Parameters
         ----------
@@ -1469,16 +1716,15 @@ class Scene:
 
                     # second option: within the call to Scene.play
                     self.play(
-                        Transform(square, circle),
-                        subcaption="The square transforms."
+                        Transform(square, circle), subcaption="The square transforms."
                     )
 
         """
         subtitle = srt.Subtitle(
             index=len(self.renderer.file_writer.subcaptions),
             content=content,
-            start=datetime.timedelta(seconds=self.renderer.time + offset),
-            end=datetime.timedelta(seconds=self.renderer.time + offset + duration),
+            start=datetime.timedelta(seconds=float(self.time + offset)),
+            end=datetime.timedelta(seconds=float(self.time + offset + duration)),
         )
         self.renderer.file_writer.subcaptions.append(subtitle)
 
@@ -1487,8 +1733,8 @@ class Scene:
         sound_file: str,
         time_offset: float = 0,
         gain: float | None = None,
-        **kwargs,
-    ):
+        **kwargs: Any,
+    ) -> None:
         """
         This method is used to add a sound to the animation.
 
@@ -1526,10 +1772,12 @@ class Scene:
         """
         if self.renderer.skip_animations:
             return
-        time = self.renderer.time + time_offset
+        time = self.time + time_offset
         self.renderer.file_writer.add_sound(sound_file, time, gain, **kwargs)
 
-    def on_mouse_motion(self, point, d_point):
+    def on_mouse_motion(self, point: Point3D, d_point: Point3D) -> None:
+        assert isinstance(self.camera, OpenGLCamera)
+        assert isinstance(self.renderer, OpenGLRenderer)
         self.mouse_point.move_to(point)
         if SHIFT_VALUE in self.renderer.pressed_keys:
             shift = -d_point
@@ -1539,13 +1787,15 @@ class Scene:
             shift = np.dot(np.transpose(transform), shift)
             self.camera.shift(shift)
 
-    def on_mouse_scroll(self, point, offset):
+    def on_mouse_scroll(self, point: Point3D, offset: Point3D) -> None:
+        assert isinstance(self.camera, OpenGLCamera)
         if not config.use_projection_stroke_shaders:
             factor = 1 + np.arctan(-2.1 * offset[1])
             self.camera.scale(factor, about_point=self.camera_target)
         self.mouse_scroll_orbit_controls(point, offset)
 
-    def on_key_press(self, symbol, modifiers):
+    def on_key_press(self, symbol: int, modifiers: int) -> None:
+        assert isinstance(self.camera, OpenGLCamera)
         try:
             char = chr(symbol)
         except OverflowError:
@@ -1561,10 +1811,17 @@ class Scene:
             if char in self.key_to_function_map:
                 self.key_to_function_map[char]()
 
-    def on_key_release(self, symbol, modifiers):
+    def on_key_release(self, symbol: int, modifiers: int) -> None:
         pass
 
-    def on_mouse_drag(self, point, d_point, buttons, modifiers):
+    def on_mouse_drag(
+        self,
+        point: Point3D,
+        d_point: Point3D,
+        buttons: int,
+        modifiers: int,
+    ) -> None:
+        assert isinstance(self.camera, OpenGLCamera)
         self.mouse_drag_point.move_to(point)
         if buttons == 1:
             self.camera.increment_theta(-d_point[0])
@@ -1578,7 +1835,8 @@ class Scene:
 
         self.mouse_drag_orbit_controls(point, d_point, buttons, modifiers)
 
-    def mouse_scroll_orbit_controls(self, point, offset):
+    def mouse_scroll_orbit_controls(self, point: Point3D, offset: Point3D) -> None:
+        assert isinstance(self.camera, OpenGLCamera)
         camera_to_target = self.camera_target - self.camera.get_position()
         camera_to_target *= np.sign(offset[1])
         shift_vector = 0.01 * camera_to_target
@@ -1586,7 +1844,14 @@ class Scene:
             opengl.translation_matrix(*shift_vector) @ self.camera.model_matrix
         )
 
-    def mouse_drag_orbit_controls(self, point, d_point, buttons, modifiers):
+    def mouse_drag_orbit_controls(
+        self,
+        point: Point3D,
+        d_point: Point3D,
+        buttons: int,
+        modifiers: int,
+    ) -> None:
+        assert isinstance(self.camera, OpenGLCamera)
         # Left click drag.
         if buttons == 1:
             # Translate to target the origin and rotate around the z axis.
@@ -1659,9 +1924,9 @@ class Scene:
             )
             self.camera_target += total_shift_vector
 
-    def set_key_function(self, char, func):
+    def set_key_function(self, char: str, func: Callable[[], Any]) -> None:
         self.key_to_function_map[char] = func
 
-    def on_mouse_press(self, point, button, modifiers):
+    def on_mouse_press(self, point: Point3D, button: str, modifiers: int) -> None:
         for func in self.mouse_press_callbacks:
             func()