manim-simplex 0.2.1__tar.gz → 0.2.2__tar.gz

{manim_simplex-0.2.1 → manim_simplex-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: manim-simplex
-Version: 0.2.1
+Version: 0.2.2
 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
@@ -28,6 +28,7 @@ Requires-Dist: manim-slides>=5.1.7
 Requires-Dist: manim>=0.20.1
 Requires-Dist: pydantic>=2.7
 Requires-Dist: pygments>=2.18
+Requires-Dist: pymupdf>=1.27.2.3
 Description-Content-Type: text/markdown
 
 # manim-simplex

{manim_simplex-0.2.1 → manim_simplex-0.2.2}/pyproject.toml

@@ -33,6 +33,7 @@ dependencies = [
   "manim-slides>=5.1.7",
   "pydantic>=2.7",
   "pygments>=2.18",
+  "pymupdf>=1.27.2.3",
 ]
 description = "Manim plugin: theme tokens, mobjects, slide hierarchy, deck manifest schema."
 keywords = [
@@ -50,7 +51,7 @@ license-files = ["LICENSE"]
 name = "manim-simplex"
 readme = "README.md"
 requires-python = ">=3.13"
-version = "0.2.1"
+version = "0.2.2"
 
 [project.entry-points."manim.plugins"]
 simplex = "simplex.plugin:activate"

{manim_simplex-0.2.1 → manim_simplex-0.2.2}/src/simplex/engine/animations.py

@@ -66,10 +66,16 @@ class _DefaultRegistry:
             VMobject,
         )
 
+        from simplex.mobjects.paper import DismissPaper, Paper
+
         def fade_with_drift(m: Any, **kw: Any) -> Any:
             return FadeOut(m, shift=0.1 * DOWN, **kw)
 
+        def paper_exit(m: Any, **kw: Any) -> Any:
+            return DismissPaper(m, **kw)
+
         return {
+            Paper: paper_exit,
             Tex: Unwrite,
             MathTex: Unwrite,
             Text: Unwrite,

{manim_simplex-0.2.1 → manim_simplex-0.2.2}/src/simplex/mobjects/__init__.py

@@ -9,5 +9,17 @@ slide system.
 from simplex.mobjects.array import ArrayEntry, ArrayMob, ArrayPointer
 from simplex.mobjects.graph import Edge, Node
 from simplex.mobjects.outline import OutlineProgressBar
+from simplex.mobjects.paper import DismissPaper, Paper, PickPage, ShowPaper
 
-__all__ = ["ArrayEntry", "ArrayMob", "ArrayPointer", "Edge", "Node", "OutlineProgressBar"]
+__all__ = [
+    "ArrayEntry",
+    "ArrayMob",
+    "ArrayPointer",
+    "DismissPaper",
+    "Edge",
+    "Node",
+    "OutlineProgressBar",
+    "Paper",
+    "PickPage",
+    "ShowPaper",
+]

manim_simplex-0.2.2/src/simplex/mobjects/paper.py

@@ -0,0 +1,456 @@
+"""Paper mobject -- render academic papers (ArXiv / local PDF / BibTeX) as stacked page images.
+
+Provides:
+- ``Paper``: a ``Group`` of ``ImageMobject`` pages with configurable shadow and stacking.
+- ``ShowPaper``: intro animation that builds the stacked view.
+- ``DismissPaper``: exit animation — delegates to ``ShowPaper`` with reversed fade direction.
+- ``PickPage``: pull-from-stack animation for a given page index.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+import urllib.request
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import pymupdf
+from manim import (
+    DOWN,
+    LEFT,
+    RIGHT,
+    UP,
+    WHITE,
+    Animation,
+    AnimationGroup,
+    FadeIn,
+    FadeOut,
+    Group,
+    ImageMobject,
+    Rectangle,
+    RoundedRectangle,
+    config,
+    smooth,
+)
+from manim.utils.tex_file_writing import tex_hash
+
+logger = logging.getLogger("simplex.paper")
+
+_DEFAULT_DPI = 150
+_DEFAULT_PAGES = 3
+_DEFAULT_TIMEOUT = 30
+_SHADOW_OPACITY = 0.35
+_SHADOW_COLOR = "#000000"
+_SHADOW_OFFSET_FACTOR = 0.06
+_STACK_OFFSET_FACTOR = 0.08
+_PAGE_HEIGHT = 5.5
+_BORDER_COLOR = WHITE
+_BORDER_STROKE_WIDTH = 1.5
+
+_ARXIV_ABS_RE = re.compile(r"arxiv\.org/abs/(.+?)(?:\?|$)")
+_ARXIV_PDF_RE = re.compile(r"arxiv\.org/pdf/(.+?)(?:\.pdf)?(?:\?|$)")
+
+
+def _paper_dir() -> Path:
+    """Return (and create) the paper cache directory inside Manim's media tree."""
+    d = Path(config.media_dir) / "papers"
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def _url_to_pdf_url(url: str) -> str:
+    """Normalize an ArXiv URL to a direct PDF download link."""
+    if m := _ARXIV_ABS_RE.search(url):
+        return f"https://arxiv.org/pdf/{m.group(1)}.pdf"
+    if _ARXIV_PDF_RE.search(url):
+        return url if url.endswith(".pdf") else url + ".pdf"
+    return url
+
+
+def _download_pdf(url: str, *, timeout: int = _DEFAULT_TIMEOUT) -> Path:
+    """Download a PDF from *url*, caching on disk. Returns local path."""
+    key = tex_hash(url)
+    cached = _paper_dir() / f"{key}.pdf"
+    if cached.exists():
+        return cached
+    pdf_url = _url_to_pdf_url(url)
+    if not pdf_url.startswith(("https://", "http://")):
+        raise ValueError(f"Refusing to open non-HTTP URL: {pdf_url}")
+    logger.info("Downloading %s → %s", pdf_url, cached)
+    req = urllib.request.Request(pdf_url, headers={"User-Agent": "manim-simplex/0.2"})  # noqa: S310
+    with urllib.request.urlopen(req, timeout=timeout) as resp:  # noqa: S310
+        cached.write_bytes(resp.read())
+    return cached
+
+
+def _resolve_bibtex_source(bib_path: Path, cite_key: str) -> str:
+    """Extract an ArXiv URL or ``eprint`` field from a BibTeX entry."""
+    text = bib_path.read_text()
+    pattern = re.compile(
+        rf"@\w+\{{\s*{re.escape(cite_key)}\s*,(.*?)\n\s*\}}",
+        re.DOTALL,
+    )
+    match = pattern.search(text)
+    if not match:
+        raise ValueError(f"Cite key '{cite_key}' not found in {bib_path}")
+    body = match.group(1)
+    if ep := re.search(r"eprint\s*=\s*\{?([0-9.]+)\}?", body):
+        return f"https://arxiv.org/abs/{ep.group(1)}"
+    if url_match := re.search(r"url\s*=\s*\{(.+?)\}", body):
+        return url_match.group(1)
+    raise ValueError(f"No ArXiv eprint or URL found for '{cite_key}' in {bib_path}")
+
+
+def _render_pages(
+    pdf_path: Path,
+    *,
+    pages: int = _DEFAULT_PAGES,
+    dpi: int = _DEFAULT_DPI,
+) -> list[Path]:
+    """Render the first *pages* pages of a PDF to cached PNGs."""
+    key = tex_hash(str(pdf_path))
+    cache = _paper_dir() / key
+    cache.mkdir(parents=True, exist_ok=True)
+
+    rendered: list[Path] = []
+    doc = pymupdf.open(pdf_path)
+    n = min(pages, len(doc))
+    for i in range(n):
+        out = cache / f"page_{i}_dpi{dpi}.png"
+        if not out.exists():
+            page = doc[i]
+            zoom = dpi / 72.0
+            mat = pymupdf.Matrix(zoom, zoom)
+            pix = page.get_pixmap(matrix=mat, alpha=False)
+            pix.save(out)
+            logger.info("Rendered %s page %d → %s", pdf_path.name, i, out)
+        rendered.append(out)
+    doc.close()
+    return rendered
+
+
+# ---------------------------------------------------------------------------
+# Direction parsing (shared by Paper and animation classes)
+# ---------------------------------------------------------------------------
+
+_DIRECTION_MAP: dict[str, np.ndarray] = {
+    "dl": DOWN + LEFT,
+    "dr": DOWN + RIGHT,
+    "ul": UP + LEFT,
+    "ur": UP + RIGHT,
+    "left": LEFT,
+    "right": RIGHT,
+    "up": UP,
+    "down": DOWN,
+}
+
+
+def _parse_direction(direction: str | np.ndarray) -> np.ndarray:
+    if isinstance(direction, str):
+        key = direction.lower().strip()
+        if key in _DIRECTION_MAP:
+            return _DIRECTION_MAP[key]
+        raise ValueError(f"Unknown direction '{direction}'.")
+    return np.asarray(direction, dtype=float)
+
+
+# ---------------------------------------------------------------------------
+# Paper mobject
+# ---------------------------------------------------------------------------
+
+
+class Paper(Group):
+    """A stack of rendered PDF pages displayed as ``ImageMobject`` instances.
+
+    Parameters
+    ----------
+    source
+        One of: ArXiv URL, local PDF path, or ``(bib_path, cite_key)`` tuple.
+    pages
+        Number of pages to render (from the start of the document).
+    dpi
+        Resolution for PDF-to-image conversion.
+    page_height
+        Target height of each page in Manim units.
+    shadow
+        Whether to render a drop shadow behind pages.
+    shadow_direction
+        Direction the shadow falls (offset direction from page center).
+    shadow_opacity
+        Fill opacity of the shadow rectangles.
+    border
+        Whether to draw a thin border around each page.
+    border_color
+        Stroke color for the page border.
+    border_stroke_width
+        Stroke width for the page border.
+    stack_direction
+        Direction pages stack towards (the offset axis for peeking edges).
+    stack_offset
+        Distance between consecutive pages in the stack (Manim units).
+    timeout
+        Network timeout in seconds for downloading.
+    """
+
+    def __init__(
+        self,
+        source: str | Path | tuple[Path | str, str],
+        *,
+        pages: int = _DEFAULT_PAGES,
+        dpi: int = _DEFAULT_DPI,
+        page_height: float = _PAGE_HEIGHT,
+        shadow: bool = True,
+        shadow_direction: str | np.ndarray = "DL",
+        shadow_opacity: float = _SHADOW_OPACITY,
+        border: bool = True,
+        border_color: str = _BORDER_COLOR,
+        border_stroke_width: float = _BORDER_STROKE_WIDTH,
+        stack_direction: str | np.ndarray = "DL",
+        stack_offset: float | None = None,
+        timeout: int = _DEFAULT_TIMEOUT,
+        **kwargs: Any,
+    ) -> None:
+        self._shadow_enabled = shadow
+
+        pdf_path = self._resolve_source(source, timeout=timeout)
+        image_paths = _render_pages(pdf_path, pages=pages, dpi=dpi)
+
+        shadow_dir = _parse_direction(shadow_direction)
+        self._stack_dir = _parse_direction(stack_direction)
+        self._stack_offset = (
+            stack_offset if stack_offset is not None else page_height * _STACK_OFFSET_FACTOR
+        )
+
+        page_groups: list[Group] = []
+        for img_path in image_paths:
+            img = ImageMobject(str(img_path))
+            img.height = page_height
+
+            parts: list[Any] = []
+
+            if shadow:
+                shadow_rect = RoundedRectangle(
+                    width=img.width,
+                    height=img.height,
+                    corner_radius=0.04,
+                    fill_color=_SHADOW_COLOR,
+                    fill_opacity=shadow_opacity,
+                    stroke_width=0,
+                )
+                shadow_offset = shadow_dir * page_height * _SHADOW_OFFSET_FACTOR
+                shadow_rect.move_to(img.get_center() + shadow_offset)
+                parts.append(shadow_rect)
+
+            parts.append(img)
+
+            if border:
+                border_rect = Rectangle(
+                    width=img.width,
+                    height=img.height,
+                    stroke_color=border_color,
+                    stroke_width=border_stroke_width,
+                    stroke_opacity=0.6,
+                    fill_opacity=0,
+                )
+                border_rect.move_to(img.get_center())
+                parts.append(border_rect)
+
+            page_groups.append(Group(*parts))
+
+        # _page_groups[0] = top/front page (first PDF page), drawn last.
+        # Submobjects stored back-to-front for correct z-order.
+        self._page_groups = page_groups
+        super().__init__(*reversed(page_groups), **kwargs)
+        self._arrange_stack()
+
+    # -- source resolution ---------------------------------------------------
+
+    def _resolve_source(self, source: str | Path | tuple[Path | str, str], *, timeout: int) -> Path:
+        if isinstance(source, tuple):
+            bib_path, cite_key = source
+            url = _resolve_bibtex_source(Path(bib_path), cite_key)
+            return _download_pdf(url, timeout=timeout)
+        source_str = str(source)
+        if source_str.startswith(("http://", "https://")):
+            return _download_pdf(source_str, timeout=timeout)
+        path = Path(source_str)
+        if not path.exists():
+            raise FileNotFoundError(f"PDF not found: {path}")
+        return path
+
+    # -- layout --------------------------------------------------------------
+
+    def _arrange_stack(self) -> None:
+        """Position pages: page 0 at origin (top), others offset behind."""
+        for i, pg in enumerate(self._page_groups):
+            pg.move_to(self._stack_dir * self._stack_offset * i)
+
+    # -- public API ----------------------------------------------------------
+
+    @property
+    def page_groups(self) -> list[Group]:
+        return list(self._page_groups)
+
+    @property
+    def page_count(self) -> int:
+        return len(self._page_groups)
+
+    def get_page(self, index: int) -> Group:
+        return self._page_groups[index]
+
+    def get_top_page(self) -> Group:
+        return self._page_groups[0]
+
+    def reorder_page_to_top(self, index: int) -> None:
+        """Move page at *index* to position 0 (front of stack, drawn last)."""
+        page = self._page_groups.pop(index)
+        self._page_groups.insert(0, page)
+        self.submobjects = list(reversed(self._page_groups))
+        self._arrange_stack()
+
+
+# ---------------------------------------------------------------------------
+# Animations
+# ---------------------------------------------------------------------------
+
+
+class ShowPaper(AnimationGroup):
+    """Intro animation: pages cascade in with a lagged stagger.
+
+    Back pages appear first, then the front page lands on top — giving a
+    natural "dealing cards" effect.
+
+    When *dismiss* is ``True`` the animation flips to ``FadeOut`` and the
+    cascade order reverses (front page exits first), so ``DismissPaper``
+    can delegate here without duplicating the logic.
+
+    Parameters
+    ----------
+    paper
+        The Paper mobject to animate.
+    direction
+        Direction from which pages slide in (intro) or out (dismiss).
+    lag_ratio
+        Stagger between successive page animations.
+    dismiss
+        If ``True``, use ``FadeOut`` (exit) instead of ``FadeIn`` (intro).
+    """
+
+    def __init__(
+        self,
+        paper: Paper,
+        *,
+        direction: str | np.ndarray = "DOWN",
+        lag_ratio: float = 0.3,
+        dismiss: bool = False,
+        **kwargs: Any,
+    ) -> None:
+        shift_dir = _parse_direction(direction)
+        shift_vec = shift_dir * 2.0
+        anim_cls = FadeOut if dismiss else FadeIn
+
+        # Intro: back-to-front (last page first, top page last).
+        # Dismiss: front-to-back (top page first, last page last).
+        ordering = paper.page_groups if dismiss else list(reversed(paper.page_groups))
+
+        anims = [anim_cls(pg, shift=shift_vec) for pg in ordering]
+        kwargs.setdefault("run_time", 1.5)
+        super().__init__(*anims, lag_ratio=lag_ratio, **kwargs)
+
+
+class DismissPaper(ShowPaper):
+    """Exit animation — syntactic sugar for ``ShowPaper(..., dismiss=True)``."""
+
+    def __init__(
+        self,
+        paper: Paper,
+        *,
+        direction: str | np.ndarray = "DOWN",
+        lag_ratio: float = 0.3,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(paper, direction=direction, lag_ratio=lag_ratio, dismiss=True, **kwargs)
+
+
+class PickPage(Animation):
+    """Animate a page sliding out of the stack, then moving to the top/front.
+
+    The target page slides out in *slide_direction*, pauses visibly beside
+    the stack, then slides back to position 0 (the front). The remaining
+    pages re-settle to fill the gap.
+
+    Parameters
+    ----------
+    paper
+        The Paper mobject containing the stack.
+    page_index
+        Which page to pick (0 = current top; 1+ = pages behind it).
+    slide_direction
+        Direction the page slides out to before returning to top.
+    overshoot
+        How far (Manim units) the page travels out before settling.
+    """
+
+    def __init__(
+        self,
+        paper: Paper,
+        page_index: int = 1,
+        *,
+        slide_direction: str | np.ndarray = "RIGHT",
+        overshoot: float = 3.0,
+        **kwargs: Any,
+    ) -> None:
+        if page_index < 0 or page_index >= paper.page_count:
+            raise IndexError(f"page_index {page_index} out of range [0, {paper.page_count})")
+        self._paper = paper
+        self._page_index = page_index
+        self._slide_vec = _parse_direction(slide_direction) * overshoot
+        kwargs.setdefault("run_time", 2.0)
+        super().__init__(paper, **kwargs)
+
+    def begin(self) -> None:
+        self._page = self._paper.get_page(self._page_index)
+        self._start_pos = self._page.get_center().copy()
+
+        self._other_pages_start: list[np.ndarray] = []
+        for i, pg in enumerate(self._paper.page_groups):
+            if i != self._page_index:
+                self._other_pages_start.append(pg.get_center().copy())
+
+        self._paper.reorder_page_to_top(self._page_index)
+
+        self._end_pos = self._paper._stack_dir * self._paper._stack_offset * 0
+        self._midpoint = self._start_pos + self._slide_vec
+
+        self._other_pages_end: list[np.ndarray] = []
+        for i, _pg in enumerate(self._paper.page_groups[1:], start=1):
+            self._other_pages_end.append(self._paper._stack_dir * self._paper._stack_offset * i)
+
+        self._other_pages = self._paper.page_groups[1:]
+        super().begin()
+
+    def interpolate_mobject(self, alpha: float) -> None:
+        t = smooth(alpha)
+
+        if t < 0.5:
+            sub_t = t * 2.0
+            pos = self._start_pos + (self._midpoint - self._start_pos) * sub_t
+        else:
+            sub_t = (t - 0.5) * 2.0
+            pos = self._midpoint + (self._end_pos - self._midpoint) * sub_t
+
+        self._page.move_to(pos)
+
+        settle_t = min(t * 2.0, 1.0)
+        for i, pg in enumerate(self._other_pages):
+            start = self._other_pages_start[i]
+            end = self._other_pages_end[i]
+            pg.move_to(start + (end - start) * settle_t)
+
+    def finish(self) -> None:
+        self._page.move_to(self._end_pos)
+        for i, pg in enumerate(self._other_pages):
+            pg.move_to(self._other_pages_end[i])
+        super().finish()

manim_simplex-0.2.2/tests/mobjects/test_paper.py

@@ -0,0 +1,136 @@
+"""Tests for the Paper mobject and its animations."""
+
+from pathlib import Path
+
+import pytest
+
+pytest.importorskip("manim")
+
+import numpy as np
+
+from simplex.mobjects.paper import (
+    DismissPaper,
+    Paper,
+    PickPage,
+    ShowPaper,
+    _render_pages,
+    _url_to_pdf_url,
+)
+
+
+@pytest.fixture
+def sample_pdf(tmp_path: Path) -> Path:
+    """Create a minimal multi-page PDF for testing."""
+    import pymupdf
+
+    pdf_path = tmp_path / "test.pdf"
+    doc = pymupdf.open()
+    for i in range(5):
+        page = doc.new_page(width=612, height=792)
+        tw = pymupdf.TextWriter(page.rect)
+        tw.append((72, 72), f"Page {i + 1}", fontsize=24)
+        tw.write_text(page)
+    doc.save(pdf_path)
+    doc.close()
+    return pdf_path
+
+
+def test_arxiv_url_normalization() -> None:
+    assert _url_to_pdf_url("https://arxiv.org/abs/1706.03762") == (
+        "https://arxiv.org/pdf/1706.03762.pdf"
+    )
+    assert _url_to_pdf_url("https://arxiv.org/pdf/1706.03762") == (
+        "https://arxiv.org/pdf/1706.03762.pdf"
+    )
+    assert _url_to_pdf_url("https://arxiv.org/pdf/1706.03762.pdf") == (
+        "https://arxiv.org/pdf/1706.03762.pdf"
+    )
+
+
+def test_render_pages_creates_images(sample_pdf: Path) -> None:
+    pages = _render_pages(sample_pdf, pages=3, dpi=72)
+    assert len(pages) == 3
+    for p in pages:
+        assert p.exists()
+        assert p.suffix == ".png"
+
+
+def test_render_pages_clamps_to_document_length(sample_pdf: Path) -> None:
+    pages = _render_pages(sample_pdf, pages=100, dpi=72)
+    assert len(pages) == 5
+
+
+def test_paper_constructs_with_local_pdf(sample_pdf: Path) -> None:
+    paper = Paper(sample_pdf, pages=3, dpi=72, page_height=4.0)
+    assert paper.page_count == 3
+    assert len(paper.submobjects) == 3
+
+
+def test_paper_top_page_at_origin(sample_pdf: Path) -> None:
+    paper = Paper(sample_pdf, pages=3, dpi=72, page_height=4.0)
+    assert np.allclose(paper.get_top_page().get_center(), [0, 0, 0], atol=0.01)
+
+
+def test_paper_reorder_to_top(sample_pdf: Path) -> None:
+    paper = Paper(sample_pdf, pages=3, dpi=72, page_height=4.0)
+    original_back = paper.get_page(2)
+    paper.reorder_page_to_top(2)
+    assert paper.get_top_page() is original_back
+
+
+def test_show_paper_constructs(sample_pdf: Path) -> None:
+    paper = Paper(sample_pdf, pages=2, dpi=72, page_height=3.0)
+    anim = ShowPaper(paper, direction="DOWN")
+    assert anim.run_time == 1.5
+
+
+def test_dismiss_paper_constructs(sample_pdf: Path) -> None:
+    paper = Paper(sample_pdf, pages=2, dpi=72, page_height=3.0)
+    anim = DismissPaper(paper, direction="UP")
+    assert anim.run_time == 1.5
+
+
+def test_pick_page_constructs(sample_pdf: Path) -> None:
+    paper = Paper(sample_pdf, pages=3, dpi=72, page_height=3.0)
+    anim = PickPage(paper, page_index=2, slide_direction="RIGHT")
+    assert anim.run_time == 2.0
+
+
+def test_pick_page_out_of_range_raises(sample_pdf: Path) -> None:
+    paper = Paper(sample_pdf, pages=3, dpi=72, page_height=3.0)
+    with pytest.raises(IndexError):
+        PickPage(paper, page_index=5)
+
+
+def test_paper_exit_animation_is_dismiss(sample_pdf: Path) -> None:
+    from simplex.engine.animations import exit_for
+
+    paper = Paper(sample_pdf, pages=2, dpi=72, page_height=3.0)
+    anim = exit_for(paper)
+    assert isinstance(anim, DismissPaper)
+
+
+def test_paper_without_shadow(sample_pdf: Path) -> None:
+    paper = Paper(sample_pdf, pages=2, dpi=72, page_height=3.0, shadow=False, border=False)
+    assert paper.page_count == 2
+    for pg in paper.page_groups:
+        assert len(pg.submobjects) == 1
+
+
+def test_paper_with_border_no_shadow(sample_pdf: Path) -> None:
+    paper = Paper(sample_pdf, pages=2, dpi=72, page_height=3.0, shadow=False, border=True)
+    assert paper.page_count == 2
+    for pg in paper.page_groups:
+        assert len(pg.submobjects) == 2
+
+
+def test_paper_with_shadow_and_border(sample_pdf: Path) -> None:
+    paper = Paper(sample_pdf, pages=2, dpi=72, page_height=3.0, shadow=True, border=True)
+    for pg in paper.page_groups:
+        assert len(pg.submobjects) == 3
+
+
+def test_dismiss_is_show_subclass(sample_pdf: Path) -> None:
+    paper = Paper(sample_pdf, pages=2, dpi=72, page_height=3.0)
+    anim = DismissPaper(paper, direction="UP")
+    assert isinstance(anim, ShowPaper)

{manim_simplex-0.2.1 → manim_simplex-0.2.2}/uv.lock

@@ -443,13 +443,14 @@ wheels = [
 
 [[package]]
 name = "manim-simplex"
-version = "0.2.1"
+version = "0.2.2"
 source = { editable = "." }
 dependencies = [
     { name = "manim" },
     { name = "manim-slides" },
     { name = "pydantic" },
     { name = "pygments" },
+    { name = "pymupdf" },
 ]
 
 [package.dev-dependencies]
@@ -467,6 +468,7 @@ requires-dist = [
     { name = "manim-slides", specifier = ">=5.1.7" },
     { name = "pydantic", specifier = ">=2.7" },
     { name = "pygments", specifier = ">=2.18" },
+    { name = "pymupdf", specifier = ">=1.27.2.3" },
 ]
 
 [package.metadata.requires-dev]
@@ -1016,6 +1018,22 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
 ]
 
+[[package]]
+name = "pymupdf"
+version = "1.27.2.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/22/32/708bedc9dde7b328d45abbc076091769d44f2f24ad151ad92d56a6ec142b/pymupdf-1.27.2.3.tar.gz", hash = "sha256:7a92faa25129e8bbec5e50eeb9214f187665428c31b05c4ef6e36c58c0b1c6d2", size = 85759618, upload-time = "2026-04-24T14:13:14.42Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/09/ddbdfa7ee91fbabd6f63d7d744884cbdfe3e7ff9b8604749fb38bddf5c5d/pymupdf-1.27.2.3-cp310-abi3-macosx_10_9_x86_64.whl", hash = "sha256:fc1bc3cae6e9e150b0dbb0a9221bdfd411d65f0db2fe359eaa22467d7cc2a05f", size = 24002636, upload-time = "2026-04-24T14:09:17.459Z" },
+    { url = "https://files.pythonhosted.org/packages/01/89/3f8edd6c4f50ca370e2a2f2a3011face36f3760728ffe76dffec91c0fca0/pymupdf-1.27.2.3-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:660d93cb6da5bbddf11d3982ae27745dd3a9902d9f24cdb69adab83962294b5a", size = 23278238, upload-time = "2026-04-24T14:09:32.882Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/26/b7e5a70eb83bd189f8b5df87ec442746b992f2f632662839b288170d357d/pymupdf-1.27.2.3-cp310-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:1dd460a3ae4597a755f00a3bd9771f5ebf1531dc111f6a36bf05dd00a6b84425", size = 24333923, upload-time = "2026-04-24T14:09:47.341Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/a0/aa1ee2240f29481a04a827c313333b4ecd8a14d6ac3e15d3f41a30574781/pymupdf-1.27.2.3-cp310-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:857842b4888827bd6155a1131341b2822a7ebe9a8c15a975fd7d490d7a64a30c", size = 24963198, upload-time = "2026-04-24T14:10:07.408Z" },
+    { url = "https://files.pythonhosted.org/packages/69/49/4f742451f980840829fc00ba158bebb25d389c846d8f4f8c65936ee55de8/pymupdf-1.27.2.3-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:580983849c64a08d08344ca3d1580e87c01f046a8392421797bc850efd72a5b6", size = 25184609, upload-time = "2026-04-24T14:10:22.911Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/3f/3853d6608f394faf6eec2bd4e8ea9f6a00beea329b071abdb29f4164cc3d/pymupdf-1.27.2.3-cp310-abi3-win32.whl", hash = "sha256:a5c1088a87189891a4946ab314a14b7934ac4c5b6077f7e74ebee956f8906d0e", size = 18019286, upload-time = "2026-04-24T14:10:34.239Z" },
+    { url = "https://files.pythonhosted.org/packages/44/47/5fb10fe73f96b31253a41647c362ea9e0380920bddf16028414a051247fc/pymupdf-1.27.2.3-cp310-abi3-win_amd64.whl", hash = "sha256:d20f68ef15195e073071dbc4ae7455257c7889af7584e39df490c0a92728526e", size = 19249102, upload-time = "2026-04-24T14:10:46.72Z" },
+    { url = "https://files.pythonhosted.org/packages/53/a4/b9e91aac82293f9c954654c85581ee8212b5b05efadc534b581141241e6f/pymupdf-1.27.2.3-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:77691604c5d1d0233827139bbcdea61fd57879c84712b8e49b1f45520f7ab9c2", size = 25000393, upload-time = "2026-04-24T14:11:01.669Z" },
+]
+
 [[package]]
 name = "pyobjc-core"
 version = "12.1"