manim-simplex 0.2.0__py3-none-any.whl

manim_simplex-0.2.0.dist-info/METADATA

@@ -0,0 +1,214 @@
+Metadata-Version: 2.4
+Name: manim-simplex
+Version: 0.2.0
+Summary: Manim plugin: theme tokens, mobjects, slide hierarchy, deck manifest schema.
+Project-URL: Changelog, https://github.com/shlomi-perles/manim-simplex/blob/main/CHANGELOG.md
+Project-URL: Homepage, https://github.com/shlomi-perles/manim-simplex
+Project-URL: Issues, https://github.com/shlomi-perles/manim-simplex/issues
+Project-URL: Repository, https://github.com/shlomi-perles/manim-simplex
+Author: Shlomi Perles
+License-Expression: MIT
+License-File: LICENSE
+Keywords: animation,computer-science,education,lecture,manim,manim-slides,math,presentation
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Education
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Typing :: Typed
+Requires-Python: >=3.13
+Requires-Dist: manim-slides>=5.1.7
+Requires-Dist: manim>=0.20.1
+Requires-Dist: pydantic>=2.7
+Requires-Dist: pygments>=2.18
+Description-Content-Type: text/markdown
+
+# manim-simplex
+
+[![PyPI version](https://img.shields.io/pypi/v/manim-simplex.svg)](https://pypi.org/project/manim-simplex/)
+[![Python](https://img.shields.io/pypi/pyversions/manim-simplex.svg)](https://pypi.org/project/manim-simplex/)
+[![License](https://img.shields.io/pypi/l/manim-simplex.svg)](https://github.com/shlomi-perles/manim-simplex/blob/main/LICENSE)
+
+The Manim plugin half of [Simplex](https://github.com/shlomi-perles/simplex):
+theme tokens, reusable mobjects, slide hierarchy, deck manifest schema,
+and the `manim.plugins` entry-point. Distributed on PyPI as
+`manim-simplex`.
+
+The lecture-portal platform (CLI, deck discovery, render orchestration,
+web builder) lives in the sibling [`simplex`](https://github.com/shlomi-perles/simplex)
+package; both contribute modules to the shared PEP 420 `simplex/`
+namespace.
+
+## What ships here
+
+| Module | Contents |
+|---|---|
+| `simplex.plugin` | `activate()` -- the `manim.plugins` entry-point. Applies the active theme to `manim.config`. |
+| `simplex.section` | `SimplexSectionType` enum -- the slide-hierarchy strings written into Manim's sections JSON. Manim-free. |
+| `simplex.manifest` | `DeckManifest`, `MainSlide`, `Subsection` Pydantic models -- the cross-package contract consumed by the `simplex` web builder. Manim-free. |
+| `simplex.theme` | `Theme`, `Palette`, `Typography`, `Spacing`, `Motion`, `LatexProfile`, `WebPalette`, `active_theme`, `get_active_theme`, `presets`, `render_web_css`. |
+| `simplex.engine` | Animation primitives -- `Region`, `Remove`, `clear_scene`, `exit_for`, `register_exit`, `set_exit_animation`, `HighlightResult`, `apply_theme_defaults`, plus the `glyph_map`, `ghost_fade`, `dynamics`, `geometry`, `code`, `text`, `scaling`, `debug` submodules. |
+| `simplex.mobjects` | `Node`, `Edge`, `ArrayMob`, `ArrayEntry`, `ArrayPointer`, `OutlineProgressBar`. |
+| `simplex.slides` | `BaseSlide`, `OutlineScene`, `OutlinePart`, `Chrome`, `make_chrome`. |
+
+## Install
+
+```bash
+uv add manim-simplex
+# or
+pip install manim-simplex
+```
+
+System dependencies (texlive, ffmpeg, cairo, pango) are the same as
+Manim's -- see the [Manim install guide](https://docs.manim.community/en/stable/installation.html).
+
+## Quick start
+
+```ini
+# decks/<your-deck>/manim.cfg
+[CLI]
+plugins = simplex
+save_sections = True
+```
+
+```python
+from manim import MathTex
+from simplex.slides import BaseSlide, make_chrome
+from simplex.theme import presets
+
+class Hello(BaseSlide):
+    def setup(self) -> None:
+        super().setup()
+        chrome = make_chrome(presets.DASTIMATOR_DARK, self.region, header="Hello")
+        self.add_to_canvas(**chrome.mobjects)
+        self.region = chrome.body_region
+
+    def construct(self) -> None:
+        from manim import ORIGIN, Write
+        eq = MathTex(r"e^{i\pi} + 1 = 0")
+        self.region.place(eq, ORIGIN)
+        self.play(Write(eq))
+        self.next_slide(name="Hello")
+```
+
+```bash
+uv run manim-slides render path/to/your_deck/scene.py Hello
+```
+
+## Slide hierarchy
+
+`BaseSlide.next_slide` writes a `SimplexSectionType` value into Manim's
+native section JSON. The web builder reconciles that with manim-slides'
+`PresentationConfig` to build a main/sub tree.
+
+- `self.next_slide(name="Title")` -> **MAIN** slide named `"Title"`.
+- `self.next_slide()` as the *first* call -> **MAIN** slide
+  auto-named after the scene class with PascalCase boundaries spaced
+  out (``DFSLecture`` → ``"DFS Lecture"``; no warning).
+- `self.next_slide()` after a named main -> **SUB** slide.
+- `self.next_slide(..., loop=True)` -> the `LOOP` variant.
+- `self.next_slide(..., section_type="simplex.main.skip")` -> explicit
+  override always wins.
+
+## Outline slides
+
+`OutlineScene` composes typed `OutlinePart` objects into an animated
+`BaseSlide` outline. Each part owns already-built Manim mobjects for its
+feature title, compact label, and optional visual. Progress dots are
+positioned with `self.region.linspace(RIGHT, n)` defaults, so edge
+margins and inter-dot gaps are equal.
+
+```python
+from manim import Circle, Square, Tex
+from simplex.engine.text import Caption
+from simplex.slides import OutlinePart, OutlineScene
+
+class Outline(OutlineScene):
+    def __init__(self, **kwargs):
+        super().__init__(
+            parts=[
+                OutlinePart(Tex("Research Question"), Caption("Question"), Circle()),
+                OutlinePart(Tex("Algorithms"), Caption("Algorithms"), Square()),
+            ],
+            **kwargs,
+        )
+```
+
+## Theme
+
+Themes are frozen Pydantic models -- the same instance produces:
+
+1. Manim defaults (via `apply_theme_defaults`, called by the plugin).
+2. A `TexTemplate` (via `LatexProfile.as_tex_template`).
+3. CSS variables for the web portal + RevealJS HTML (via
+   `render_web_css(theme.web_palette)`).
+4. The `darcula` Pygments style (registered by the plugin).
+
+Switch themes per-scope with `active_theme`:
+
+```python
+from simplex.theme import presets
+from simplex.theme.context import active_theme
+
+from manim import Tex
+
+with active_theme(presets.ACADEMIC_LIGHT):
+    label = Tex("This Tex picks up the academic light palette.")
+```
+
+## Cross-package contract
+
+`manim-simplex` owns the manifest schema; `simplex` imports it:
+
+```python
+from simplex.manifest import DeckManifest, MainSlide, Subsection
+```
+
+When the schema bumps `schema_version`, the web builder hard-fails on
+unknown versions with a pointer at the `manim-simplex` upgrade. This
+keeps the two repos honest about their contract.
+
+## Why a separate distribution?
+
+The plugin surface (mobjects + theme + entry-point + manifest schema)
+is reusable independently of the lecture-portal pipeline. Splitting
+them lets the plugin be a thin dependency for users who want to render
+slides without pulling in Typer, watchfiles, Jinja, and the web
+builder stack.
+
+Python's PEP 420 implicit namespace packages merge the two distributions
+at import time. Neither wheel ships `src/simplex/__init__.py`, so
+`from simplex.engine import Remove` resolves regardless of which wheel
+contributed the module.
+
+## Development
+
+Requires Python 3.13+ and [uv](https://docs.astral.sh/uv/).
+
+```bash
+git clone https://github.com/shlomi-perles/manim-simplex.git
+cd manim-simplex
+uv sync --all-extras
+uv run pre-commit install
+uv run pytest -q
+uv run ruff check .
+uv run basedpyright
+```
+
+Examples under `examples/` are runnable demo scenes; they double as
+documentation and CI smoke tests:
+
+```bash
+uv run manim -pql examples/hello_slide.py HelloSlide
+```
+
+## License
+
+MIT.

manim_simplex-0.2.0.dist-info/RECORD

@@ -0,0 +1,39 @@
+simplex/manifest.py,sha256=g7pQoTJb0fD_FGvvXFmNkwMrNDR5mPTWm8GD4etEZzs,3646
+simplex/plugin.py,sha256=aIMQhTgOAv8gv-ZvPTNPJ-NMM3W1OtOC8lvLZetLfF4,2990
+simplex/section.py,sha256=tJfR5rVPAG-Wud0dM-wNeCexfDgRtu4fupGX-ojEFs4,1654
+simplex/engine/README.md,sha256=rHMhErOWc9X6aq6k75I1aVjIyhjNFvrL9LSiYiTfCDk,2991
+simplex/engine/__init__.py,sha256=WyGyuduPx1c3ESuDkHPs78JqXIRBavGYJcFV0_EuTVg,808
+simplex/engine/animations.py,sha256=X-y1hA9o9woRJIPfMw3zqSS0ePn5sKCJtJwfjmuCNM0,5565
+simplex/engine/code.py,sha256=t-ejp9aQrey6HD_eufx1xqD-hKstvSBIn0Mg7VCOH3o,15134
+simplex/engine/debug.py,sha256=18u4udhT4XD8Sa7dXY9jxpz7jzkA08IvsQglEGTP2Mg,5636
+simplex/engine/defaults.py,sha256=ZG8I0FUMwOnpe0QmB4m_vXFOSG_FuCTLOJA6S4eLVlE,1093
+simplex/engine/dynamics.py,sha256=kxjlvGb00EKiYS0_lKvxeCjCAHSvEDKkGfkUIbrf1mc,3403
+simplex/engine/geometry.py,sha256=kjbR3DRSV1rHlGMkRGM8OF38Qhw0M4odKjQGj_zAEdQ,8279
+simplex/engine/ghost_fade.py,sha256=s3EG-Ope47gOY4miSfjdB7W-6zSIy4EiojKh1Uey6_c,2823
+simplex/engine/glyph_map.py,sha256=Fz5SfapdC6bfRoZwZ4hWvraGYImUtmQ6h14VDjxsOnQ,12820
+simplex/engine/region.py,sha256=qZvmSQhAchLEklnLwxrmpRF2_PDwH5uKWGcI49dVkGo,10821
+simplex/engine/scaling.py,sha256=_7chCXatOA8WIm2w9qDbJNgdkyWZ-F9hK4oa4LmEmag,2456
+simplex/engine/text.py,sha256=3O3TuNLiOCX5-Wgjx9gRRoBMFuc-UilnvsZqdBukb7w,3909
+simplex/mobjects/README.md,sha256=_vOhB65LibwkV276SCbSwj3JPhgNpBUmMawSJhro-Wg,1168
+simplex/mobjects/__init__.py,sha256=crKQGZN2ZwEH3kE5dAszsrVcruYkZScK6l7usnd2XFE,531
+simplex/mobjects/array.py,sha256=C02Vavj8c7rK2Pa0HchP354MGwPAWi2Mir8Nuiovc2A,13700
+simplex/mobjects/graph.py,sha256=HtuDYESlt7aJgCu0KbLy5NKqk81-Ow60b6Y-d_8DkIA,1983
+simplex/mobjects/outline.py,sha256=3uQiyT6NCaDBx9jLu6vc7hl7yDYUNQhxKlVIKarMhiU,5065
+simplex/slides/README.md,sha256=h2XjoR3FqwXDS43dFtBakUKwloUKWpqDlUVDFL-njrc,2018
+simplex/slides/__init__.py,sha256=rbcsHN8BlImuEjpXzFPsAADX9dCoDXvdDhVzIgTAy8w,469
+simplex/slides/base.py,sha256=9bpOtIdLhe3FYiE2pJo3XVdPCXbH1XRk6LkDmmYBM_U,4488
+simplex/slides/chrome.py,sha256=PACBPP7IZ40RBoE6aXHLxGwSAX0RpkwnS64zjAt3ATw,2391
+simplex/slides/outline.py,sha256=PPoAMKRCLB38MF65UWryFivRW-M-A3RFuIIxCkzZh0c,15380
+simplex/theme/README.md,sha256=Ie94AOM3dC9dVdCSZo3eTXtVN8n_aRTqwIbqOtpetWQ,900
+simplex/theme/__init__.py,sha256=nK8kxrSLAGsvciEs0wrVmmrfLgAr5nyk34PdQsNYjBI,540
+simplex/theme/context.py,sha256=vDY_CtUQ6SxdnmGZFdHJ5X4vrnvbl4p8Pm53KRSpom0,787
+simplex/theme/presets.py,sha256=pRT6S57coBUSyMQcZ4lTsMtmBfz66A81TPUV_crVQUo,2429
+simplex/theme/pygments_style.py,sha256=sHkdMhwelJzZHpFDtOwy87El2SC2gUg7jp34Wc3SaGU,2789
+simplex/theme/tokens.py,sha256=2UjMGE927gVAC7dcV51Qlb9s0FUCUyPY36TTZ-lATc8,3073
+simplex/theme/web_css.py,sha256=VQURjkh038Iwu6_tt8wkfNVUD4aYcenvio3uHY1FsKs,1218
+simplex/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+manim_simplex-0.2.0.dist-info/METADATA,sha256=VqT3nJpEpkqxTfcoZKIAmBKusme0vbwuPVOJf-N__lo,7857
+manim_simplex-0.2.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+manim_simplex-0.2.0.dist-info/entry_points.txt,sha256=mEZB63zKWkjk7pWQSE9cwsO6msA9DizJwa_TV9OXnQU,50
+manim_simplex-0.2.0.dist-info/licenses/LICENSE,sha256=nl59bQ87NqHIcm_46xQjWvu0Nv630wsBOK4I1-ou9SY,1070
+manim_simplex-0.2.0.dist-info/RECORD,,

manim_simplex-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

manim_simplex-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[manim.plugins]
+simplex = simplex.plugin:activate

manim_simplex-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shlomi Perles
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

simplex/engine/README.md

@@ -0,0 +1,38 @@
+# engine/
+
+Small additive helpers that augment vanilla Manim. **Never wrap Manim's constructors.**
+
+## Public surface
+
+- `apply_theme_defaults(theme)` -- calls `Mobject.set_default(...)` for Tex / MathTex / Text / Line / Dot / Arrow / Rectangle / Square (invoked by `simplex.plugin:activate`)
+- `Region` -- mutable rectangular drawing area; default lives on `BaseSlide.region`
+- `Remove(mob, **kw)` -- exit animation lookup; dispatches through `exit_for(mob)`
+- `exit_for(mob, **kw)` -- per-instance override (WeakKeyDictionary) -> MRO match in defaults -> `FadeOut`
+- `register_exit(mob_type, factory)` -- register a default exit for a Mobject class
+- `set_exit_animation(mob, factory)` -- per-instance exit override (stored in a `WeakKeyDictionary`; no monkey-patching)
+- `clear_scene(scene, *, exclude=())` -- free function used by `BaseSlide.clear_scene`
+- `HighlightResult` -- typed return for `highlight_code_lines` (fade + optional indicate, iterable)
+
+Cross-package types live one level up:
+
+- `simplex.section.SimplexSectionType` -- enum encoded into Manim's section JSON
+- `simplex.manifest.DeckManifest` / `MainSlide` / `Subsection` -- web builder contract
+
+## Submodules (import directly to keep `simplex.engine` cheap)
+
+- `engine.text` -- `Caption`, `TexPage` (fixed-width minipage; `width_cm` kwarg / class attr); `color_tex(eq, t2c)`; `search_shape_in_text`. Body-sized paragraphs use plain `manim.Tex` -- `apply_theme_defaults` already sets `font_size=theme.typography.body`.
+- `engine.code` -- `code_block`, `highlight_code_lines`, `code_explain`, `transform_code_lines`; `DarculaStyle`, `register_darcula`; `HighlightResult`
+- `engine.geometry` -- `get_convex_hull_polygon`, `get_surrounding_rectangle`, `get_frame_center`, `Vcis`, `Arc3d`, `SurroundingRectangleUnion`
+- `engine.glyph_map` -- `TransformByGlyphMap` (glyph-indexed Tex transitions)
+- `engine.ghost_fade` -- `GhostSlideFade` (one-shot fade-in/drift/fade-out cue)
+- `engine.dynamics` -- `VT` (`~`/`@`/`@=` over `ValueTracker`), `DN` (auto-tracking `DecimalNumber`), `keep_orientation`, `maintain_apparent_stroke_width`
+- `engine.scaling` -- `scale_to_fit` (multi-axis fit + buff), `scale_to_fit_mobject`, `scale_with_stroke_width`
+- `engine.debug` -- `bounding_box`, `indexx_labels` (multi-color), `debug_glyph(s)`
+
+## Don't
+
+- Don't call `Mobject.set_default(...)` outside `apply_theme_defaults`.
+- Don't subclass Manim Mobjects to inject defaults; use `set_default` via `apply_theme_defaults`.
+- Don't reimplement what Manim ships: `ValueTracker` arithmetic ops, `index_labels`, `ConvexHull`, `Union`, `Polygon.round_corners`, `scale_to_fit_height/_width/_depth`, `BraceLabel`/`BraceText`, `Mobject.always` -- all already in 0.20.x.
+- Don't import Manim at module load time from animations / region / defaults -- import inside the function so importing `simplex.engine` stays cheap.
+- Don't monkey-patch Mobjects (no `_simplex_*` attributes). Use the `WeakKeyDictionary` registry in `animations.py` instead.

simplex/engine/__init__.py

@@ -0,0 +1,31 @@
+"""Engine helpers that augment vanilla Manim.
+
+The engine ships animation primitives, layout helpers, and small custom
+mobjects -- everything that *isn't* a Slide and *isn't* a theme token.
+
+Cross-package types like ``SimplexSectionType`` live at the package root
+(``simplex.section``) so the web builder and CLI can import them without
+touching Manim.
+"""
+
+from simplex.engine.animations import (
+    Remove,
+    clear_scene,
+    exit_for,
+    register_exit,
+    set_exit_animation,
+)
+from simplex.engine.code import HighlightResult
+from simplex.engine.defaults import apply_theme_defaults
+from simplex.engine.region import Region
+
+__all__ = [
+    "HighlightResult",
+    "Region",
+    "Remove",
+    "apply_theme_defaults",
+    "clear_scene",
+    "exit_for",
+    "register_exit",
+    "set_exit_animation",
+]

simplex/engine/animations.py

@@ -0,0 +1,160 @@
+"""Default-exit registry, ``Remove``, ``set_exit_animation``, and ``clear_scene``.
+
+Each Mobject type has a default *exit* animation (e.g. ``Tex`` -> ``Unwrite``,
+``Circle`` -> ``ShrinkToCenter``). Callers can override per-instance via
+``set_exit_animation(mob, anim_cls_or_factory)``, or per-type via
+``register_exit(type, factory)``.
+
+``Remove(mob)`` and ``clear_scene(scene, exclude=...)`` both dispatch through
+``exit_for(mob)``, which checks instance overrides, then walks the MRO of
+``type(mob)`` against the type defaults, falling back to ``FadeOut``.
+
+Implementation notes:
+
+- The type defaults dict is wrapped in a ``_DefaultRegistry`` singleton with
+  a double-checked ``threading.Lock`` around its lazy init. Manim renders are
+  mostly single-threaded but plugins can be poked from setup hooks running
+  in parallel (e.g. test suites), so the lock is cheap insurance.
+- Per-instance overrides are kept in a ``WeakKeyDictionary`` keyed by the
+  Mobject, *not* monkey-patched onto the Mobject as a ``_simplex_exit``
+  attribute. Manim's Mobject base is plain-class so both ``__hash__`` (id
+  identity) and ``__weakref__`` work; if a downstream subclass disables one
+  of these the override call fails fast at ``set_exit_animation`` time
+  rather than leaking through a swallowed ``setattr``.
+"""
+
+import threading
+from collections.abc import Callable, Iterable
+from typing import Any
+from weakref import WeakKeyDictionary
+
+ExitFactory = Callable[..., Any]
+
+
+class _DefaultRegistry:
+    """Type -> exit-factory map with double-checked locked lazy init."""
+
+    def __init__(self) -> None:
+        self._lock = threading.Lock()
+        self._map: dict[type, ExitFactory] | None = None
+
+    def get(self) -> dict[type, ExitFactory]:
+        if self._map is None:
+            with self._lock:
+                if self._map is None:
+                    self._map = self._build()
+        return self._map
+
+    @staticmethod
+    def _build() -> dict[type, ExitFactory]:
+        from manim import (
+            DOWN,
+            Arrow,
+            Circle,
+            Code,
+            DashedLine,
+            Dot,
+            FadeOut,
+            Line,
+            MarkupText,
+            MathTex,
+            ShrinkToCenter,
+            Tex,
+            Text,
+            Uncreate,
+            Unwrite,
+            VMobject,
+        )
+
+        def fade_with_drift(m: Any, **kw: Any) -> Any:
+            return FadeOut(m, shift=0.1 * DOWN, **kw)
+
+        return {
+            Tex: Unwrite,
+            MathTex: Unwrite,
+            Text: Unwrite,
+            MarkupText: Unwrite,
+            Code: Unwrite,
+            Circle: ShrinkToCenter,
+            Dot: ShrinkToCenter,
+            Line: Uncreate,
+            Arrow: Uncreate,
+            DashedLine: Uncreate,
+            VMobject: fade_with_drift,
+        }
+
+
+_REGISTRY = _DefaultRegistry()
+_OVERRIDES: WeakKeyDictionary[Any, ExitFactory] = WeakKeyDictionary()
+
+
+def register_exit(mob_type: type, factory: ExitFactory) -> None:
+    """Register a default exit animation for ``mob_type`` (and subclasses via MRO).
+
+    ``factory(mob, **kwargs)`` must return an ``Animation``. Most callers pass
+    an ``Animation`` class directly (``Unwrite``, ``FadeOut``, ...) since
+    classes are callable in this signature.
+    """
+    _REGISTRY.get()[mob_type] = factory
+
+
+def set_exit_animation(mob: Any, factory: ExitFactory) -> Any:
+    """Stash a per-instance exit factory for ``mob``. Returns ``mob`` for chaining.
+
+    The override lives in a module-level ``WeakKeyDictionary`` -- it disappears
+    automatically when ``mob`` is garbage-collected. No attribute is set on
+    the Mobject itself.
+    """
+    try:
+        _OVERRIDES[mob] = factory
+    except TypeError as exc:  # mob is not hashable or weakref-able
+        raise TypeError(
+            f"set_exit_animation: {type(mob).__name__} cannot be used as a "
+            "registry key (no __weakref__ or unhashable). Wrap the mobject "
+            "in a VGroup or pass a different mobject."
+        ) from exc
+    return mob
+
+
+def exit_for(mob: Any, **kwargs: Any) -> Any:
+    """Return an ``Animation`` that exits ``mob``.
+
+    Resolution order:
+
+    1. per-instance override registered by ``set_exit_animation``;
+    2. exact type or MRO match in the default registry;
+    3. ``FadeOut`` fallback.
+
+    Any ``**kwargs`` are forwarded to the resolved factory.
+    """
+    override = _OVERRIDES.get(mob)
+    if override is not None:
+        return override(mob, **kwargs) if kwargs else override(mob)
+    defaults = _REGISTRY.get()
+    for cls in type(mob).__mro__:
+        factory = defaults.get(cls)
+        if factory is not None:
+            return factory(mob, **kwargs) if kwargs else factory(mob)
+    from manim import FadeOut
+
+    return FadeOut(mob, **kwargs)
+
+
+def Remove(mob: Any, **kwargs: Any) -> Any:  # noqa: N802 -- mirrors Manim's PascalCase Animations
+    """Alias for ``exit_for(mob, **kwargs)`` -- spelled to match Manim animations."""
+    return exit_for(mob, **kwargs)
+
+
+def clear_scene(scene: Any, *, exclude: Iterable[Any] = ()) -> None:
+    """Play exit animations for every Mobject not in ``exclude``.
+
+    Uses ``scene.mobjects_without_canvas`` when available (so the
+    manim-slides canvas survives) and dispatches through ``exit_for`` so
+    per-instance and per-type overrides apply.
+    """
+    skip = set(exclude)
+    pool = getattr(scene, "mobjects_without_canvas", None) or scene.mobjects
+    targets = [m for m in pool if m not in skip]
+    if not targets:
+        return
+    scene.play(*(exit_for(m) for m in targets))