chore(version): update changelog version

* feat(cli): add `next-terminates-loop` CLI option

Closes #254

* chore(lib): fix `--next-terminates-loop`

* chore(CHANGELOG): document changes

.bumpversion.cfg

@@ -1,5 +1,9 @@
 [bumpversion]
-current_version = 4.9.2
+current_version = 5.0.0
+parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)(-rc(?P<release>\d+))?
+serialize =
+	{major}.{minor}.{patch}-rc{release}
+	{major}.{minor}.{patch}
 commit = True
 message = chore(version): bump {current_version} to {new_version}
 
@@ -10,3 +14,7 @@ replace = __version__ = "{new_version}"
 [bumpversion:file:pyproject.toml]
 search = version = "{current_version}"
 replace = version = "{new_version}"
+
+[bumpversion:file:CITATION.cff]
+search = version: v{current_version}
+replace = version: v{new_version}

.github/dependabot.yml

@@ -0,0 +1,13 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+- package-ecosystem: github-actions
+  directory: /
+  schedule:
+    interval: daily
+  labels:
+  - dependencies

.github/workflows/clearcache.yml

@@ -0,0 +1,34 @@
+# From: https://docs.github.com/en/actions/using-workflows/caching-dependencies-to-speed-up-workflows#force-deleting-cache-entries
+name: Cleanup caches by a branch
+on:
+  pull_request:
+    types:
+    - closed
+
+jobs:
+  cleanup:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Check out code
+      uses: actions/checkout@v4
+
+    - name: Cleanup
+      run: |
+        gh extension install actions/gh-actions-cache
+
+        REPO=${{ github.repository }}
+        BRANCH="refs/pull/${{ github.event.pull_request.number }}/merge"
+
+        echo "Fetching list of cache key"
+        cacheKeysForPR=$(gh actions-cache list -R $REPO -B $BRANCH | cut -f 1 )
+
+        ## Setting this to not fail the workflow while deleting cache keys.
+        set +e
+        echo "Deleting caches..."
+        for cacheKey in $cacheKeysForPR
+        do
+            gh actions-cache delete $cacheKey -R $REPO -B $BRANCH --confirm
+        done
+        echo "Done"
+      env:
+        GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/codeql-analysis.yml

@@ -38,7 +38,7 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL

.github/workflows/draft-pdf.yml

@@ -0,0 +1,33 @@
+# Simple workflow for deploying static content to GitHub Pages
+name: Create JOSE Paper
+
+on:
+  # Runs on pushes targeting the default branch
+  push:
+    paths:
+    - paper/*
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+  paper:
+    runs-on: ubuntu-latest
+    name: Paper Draft
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+    - name: Build draft PDF
+      uses: openjournals/openjournals-draft-action@master
+      with:
+        journal: jose
+          # This should be the path to the paper within your repo.
+        paper-path: paper/paper.md
+    - name: Upload
+      uses: actions/upload-artifact@v3
+      with:
+        name: paper
+        # This is the output path where Pandoc will write the compiled
+        # PDF. Note, this should be the same directory as the input
+        # paper.md
+        path: paper/paper.pdf

.github/workflows/languagetool.yml

@@ -8,7 +8,7 @@ jobs:
   languagetool_check:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v4
     - uses: reviewdog/action-languagetool@v1
       with:
         reporter: github-pr-review

.github/workflows/pages.yml

@@ -25,13 +25,14 @@ concurrency:
 jobs:
   # Single deploy job since we're just deploying
   deploy:
+    permissions: write-all
     environment:
       name: github-pages
       url: ${{ steps.deployment.outputs.page_url }}
     runs-on: ubuntu-latest
     steps:
     - name: Checkout
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
     - name: Install Poetry
       run: pipx install poetry
     - name: Install Python
@@ -40,42 +41,46 @@ jobs:
         python-version: '3.9'
         cache: poetry
     - name: Setup Pages
-      uses: actions/configure-pages@v2
+      uses: actions/configure-pages@v3
     - name: Install Linux Dependencies
       run: |
         sudo apt-get update
         sudo apt-get install libcairo2-dev libpango1.0-dev ffmpeg freeglut3-dev
-    - name: Install Python dependencies
-      run: pip install manim sphinx sphinx_click furo
+    - name: Setup Pandoc
+      uses: nikeee/setup-pandoc@v1
     - name: Install local Python package
       run: poetry install --with docs
+    - name: Install IPython kernel
+      run: poetry run ipython kernel install --name "manim-slides" --user
     - name: Restore cached media
       id: cache-media-restore
       uses: actions/cache/restore@v3
       with:
-        path: media
-        key: ${{ runner.os }}-media
-    - name: Build animation and convert it into HTML slides
+        path: docs/media
+        key: ${{ runner.os }}-docs-media
+    - name: Clear cache
       run: |
-        poetry run manim example.py ConvertExample BasicExample ThreeDExample
-        poetry run manim-slides convert ConvertExample docs/source/_static/slides.html -ccontrols=true
-        poetry run manim-slides convert BasicExample docs/source/_static/basic_example.html -ccontrols=true
-        poetry run manim-slides convert ThreeDExample docs/source/_static/three_d_example.html -ccontrols=true
+        gh extension install actions/gh-actions-cache
+        gh actions-cache delete ${{ steps.cache-media-restore.outputs.cache-primary-key }} --confirm || true
+      env:
+        GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
     - name: Save media to cache
       id: cache-media-save
       uses: actions/cache/save@v3
       with:
-        path: media
+        path: docs/media
         key: ${{ steps.cache-media-restore.outputs.cache-primary-key }}
     - name: Build docs
       run: cd docs && poetry run make html
     - name: Upload artifact
       if: github.event_name != 'pull_request'
-      uses: actions/upload-pages-artifact@v1
+      uses: actions/upload-pages-artifact@v2
       with:
         # Upload docs/build/html dir
         path: docs/build/html/
+    - name: Show docs/build/html/_static/ dir content (video only)
+      run: tree -L 3 docs/build/html/_static/ -P '*.mp4'
     - name: Deploy to GitHub Pages
       id: deployment
       if: github.event_name != 'pull_request'
-      uses: actions/deploy-pages@v1
+      uses: actions/deploy-pages@v2

.github/workflows/python-publish.yml

@@ -1,4 +1,3 @@
-# Modified from: https://github.com/pypa/cibuildwheel
 name: Upload Python Package
 
 on:
@@ -8,41 +7,28 @@ on:
     types: [published]
 
 jobs:
-  build_wheels:
-    name: Build wheels on ${{ matrix.os }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest]
+  build_and_release:
+    name: Build and release
+    runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v2
+    - name: Checkout repository
+      uses: actions/checkout@v4
 
-    - uses: actions/setup-python@v2
+    - name: Install Poetry
+      run: pipx install poetry
 
-    - name: Install build package
-      run: python -m pip install -U build
+    - name: Install Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.10'
+        cache: poetry
 
     - name: Build wheels
-      run: python -m build --sdist
+      run: poetry build
 
-    - uses: actions/upload-artifact@v2
-      with:
-        name: dist
-        path: dist/*.tar.*
-
-  release:
-    name: Release
-    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags')
-    runs-on: ubuntu-latest
-    needs: [build_wheels]
-    steps:
-    - uses: actions/download-artifact@v2
-      with:
-        name: dist
-        path: dist/
-    - name: Upload to PyPI
-      uses: pypa/gh-action-pypi-publish@master
-      with:
-        user: __token__
-        password: ${{ secrets.PYPI_API_TOKEN }}
+    - name: Publish to PyPI
+      if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags')
+      env:
+        POETRY_PYPI_TOKEN_PYPI: ${{ secrets.PYPI_API_TOKEN }}
+      run: poetry publish

.github/workflows/test_examples.yml

@@ -1,120 +0,0 @@
-on:
-  pull_request:
-    paths:
-    - '**.py'
-    - .github/workflows/test_examples.yml
-  workflow_dispatch:
-
-name: Test Examples
-
-env:
-  QT_QPA_PLATFORM: offscreen
-  MANIM_SLIDES_VERBOSITY: debug
-  PYTHONFAULTHANDLER: 1
-  DISPLAY: :99
-
-jobs:
-  build-examples:
-    strategy:
-      fail-fast: false
-      matrix:
-        manim: [manim, manimgl]
-        os: [macos-latest, ubuntu-latest, windows-latest]
-        pyversion: ['3.8', '3.9', '3.10', '3.11']
-        exclude:
-        # excludes manimgl on Windows because if throws errors
-        # related to OpenGL, which seems hard to fix:
-        # Your graphics drivers do not support OpenGL 2.0.
-        - os: windows-latest
-          manim: manimgl
-        # We only test Python 3.11 on Windows and MacOS
-        - os: windows-latest
-          pyversion: '3.8'
-        - os: windows-latest
-          pyversion: '3.9'
-        - os: windows-latest
-          pyversion: '3.10'
-          manim: manim
-        - os: macos-latest
-          pyversion: '3.8'
-        - os: macos-latest
-          pyversion: '3.9'
-        - os: macos-latest
-          pyversion: '3.10'
-          manim: manim
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v3
-    - name: Install Poetry
-      run: pipx install poetry
-    - name: Install Python
-      uses: actions/setup-python@v4
-      with:
-        python-version: ${{ matrix.pyversion }}
-        cache: poetry
-
-      # Path related stuff
-    - name: Append to Path on MacOS
-      if: matrix.os == 'macos-latest'
-      run: |
-        echo "${HOME}/.local/bin" >> $GITHUB_PATH
-        echo "/Users/runner/Library/Python/${{ matrix.pyversion }}/bin" >> $GITHUB_PATH
-    - name: Append to Path on Ubuntu
-      if: matrix.os == 'ubuntu-latest'
-      run: echo "${HOME}/.local/bin" >> $GITHUB_PATH
-    - name: Append to Path on Windows
-      if: matrix.os == 'windows-latest'
-      run: echo "${HOME}/.local/bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
-
-      # OS depedencies
-    - name: Install manim dependencies on MacOs
-      if: matrix.os == 'macos-latest' && matrix.manim == 'manim'
-      run: brew install ffmpeg py3cairo
-    - name: Install manimgl dependencies on MacOS
-      if: matrix.os == 'macos-latest' && matrix.manim == 'manimgl'
-      run: brew install ffmpeg
-    - name: Run apt-get update on Ubuntu
-      if: matrix.os == 'ubuntu-latest'
-      run: sudo apt-get update
-    - name: Install manim dependencies on Ubuntu
-      if: matrix.os == 'ubuntu-latest' && matrix.manim == 'manim'
-      run: |
-        sudo apt-get install libcairo2-dev libpango1.0-dev ffmpeg freeglut3-dev
-    - name: Install manimgl dependencies on Ubuntu
-      if: matrix.os == 'ubuntu-latest' && matrix.manim == 'manimgl'
-      run: |
-        sudo apt-get install libpango1.0-dev ffmpeg freeglut3-dev
-    - name: Install xvfb on Ubuntu
-      if: matrix.os == 'ubuntu-latest' && matrix.manim == 'manimgl'
-      run: |
-        sudo apt-get install xvfb
-        nohup Xvfb $DISPLAY &
-    - name: Install Windows dependencies
-      if: matrix.os == 'windows-latest'
-      run: choco install ffmpeg
-
-      # Install Manim Slides
-    - name: Install Manim Slides
-      run: |
-        poetry config experimental.new-installer false
-        poetry install --with test
-
-    # Render slides
-    - name: Render slides
-      if: matrix.manim == 'manim'
-      run: poetry run manim -ql example.py BasicExample ThreeDExample
-    - name: Render slides
-      if: matrix.manim == 'manimgl'
-      run: poetry run -v manimgl -l example.py BasicExample ThreeDExample
-
-    # Play slides
-    - name: Test slides
-      run: poetry run manim-slides BasicExample ThreeDExample --skip-all
-
-    # Test slides to html
-    - name: Test convert on Ubuntu
-      if: matrix.os == 'ubuntu-latest' && matrix.manim == 'manim'
-      run: |
-        poetry run manim -ql example.py ConvertExample
-        poetry run manim-slides convert --to=html ConvertExample index.html

.github/workflows/tests.yml

@@ -0,0 +1,91 @@
+on:
+  push:
+    branches:
+    - main
+  pull_request:
+  workflow_dispatch:
+
+name: Tests
+
+jobs:
+  pytest:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [macos-latest, ubuntu-latest, windows-latest]
+        pyversion: ['3.8', '3.9', '3.10', '3.11']
+    runs-on: ${{ matrix.os }}
+    env:
+      QT_QPA_PLATFORM: offscreen
+      MANIM_SLIDES_VERBOSITY: error
+      PYTHONFAULTHANDLER: 1
+      DISPLAY: :99
+      GITHUB_WORKFLOWS: 1
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    - name: Install Poetry
+      run: pipx install poetry
+
+    - name: Install Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.pyversion }}
+        cache: poetry
+
+      # Path related stuff
+    - name: Append to Path on MacOS
+      if: matrix.os == 'macos-latest'
+      run: |
+        echo "${HOME}/.local/bin" >> $GITHUB_PATH
+        echo "/Users/runner/Library/Python/${{ matrix.pyversion }}/bin" >> $GITHUB_PATH
+
+    - name: Append to Path on Ubuntu
+      if: matrix.os == 'ubuntu-latest'
+      run: echo "${HOME}/.local/bin" >> $GITHUB_PATH
+
+    - name: Append to Path on Windows
+      if: matrix.os == 'windows-latest'
+      run: echo "${HOME}/.local/bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+
+      # OS depedencies
+    - name: Install manim dependencies on MacOS
+      if: matrix.os == 'macos-latest'
+      run: brew install ffmpeg py3cairo
+
+    - name: Install manim dependencies on Ubuntu
+      if: matrix.os == 'ubuntu-latest'
+      run: |
+        sudo apt-get update
+        sudo apt-get install libcairo2-dev libpango1.0-dev ffmpeg freeglut3-dev
+        sudo apt-get install xvfb
+        nohup Xvfb $DISPLAY &
+
+    - name: Install Windows dependencies
+      if: matrix.os == 'windows-latest'
+      run: choco install ffmpeg
+
+    - name: Install Mesa
+      if: matrix.os == 'windows-latest'
+      uses: ssciwr/setup-mesa-dist-win@v1
+
+    - name: Install Manim Slides
+      run: |
+        poetry install --with test --all-extras
+
+    - name: Run pytest
+      if: matrix.os != 'ubuntu-latest' || matrix.pyversion != '3.11'
+      run: poetry run pytest
+
+    - name: Run pytest and coverage
+      if: matrix.os == 'ubuntu-latest' && matrix.pyversion == '3.11'
+      run: poetry run pytest --cov-report xml --cov=manim_slides tests/
+
+    - name: Upload to codecov.io
+      if: matrix.os == 'ubuntu-latest' && matrix.pyversion == '3.11'
+      uses: codecov/codecov-action@v3
+      env:
+        CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+      with:
+        fail_ci_if_error: true

.gitignore

@@ -1,33 +1,34 @@
+# Python files
 __pycache__/
 /env
-/tests
 /build
 /dist
 *.egg-info/
 
+# Manim files
+images/
 /media
-/presentation
-
-/.vscode
-
-slides/
-
-.manim-slides.json
+tests/data/media/
+docs/source/media/
 
+# ManimGL files
 videos/
 
-images/
+# Manim Slides files
+.manim-slides.toml
 
-docs/build/
-
-docs/source/_static/slides_assets/
-
-docs/source/_static/slides.html
+slides/
+!tests/data/slides/
 
 slides_assets/
 
+# Docs
+docs/build/
+
 slides.html
 
+docs/source/reference/.ipynb_checkpoints/
+
 docs/source/_static/basic_example_assets/
 
 docs/source/_static/basic_example.html
@@ -35,3 +36,14 @@ docs/source/_static/basic_example.html
 docs/source/_static/three_d_example.html
 
 docs/source/_static/three_d_example_assets/
+
+docs/source/reference/media/
+
+# JOSE Paper
+paper/paper.pdf
+paper/media/
+
+# Others
+coverage.xml
+
+rendering_times.csv

.pre-commit-config.yaml

@@ -1,18 +1,13 @@
 repos:
 - repo: https://github.com/pre-commit/pre-commit-hooks
-  rev: v4.4.0
+  rev: v4.5.0
   hooks:
   - id: check-yaml
   - id: check-toml
   - id: end-of-file-fixer
   - id: trailing-whitespace
-- repo: https://github.com/pycqa/isort
-  rev: 5.12.0
-  hooks:
-  - id: isort
-    name: isort (python)
 - repo: https://github.com/macisamuele/language-formatters-pre-commit-hooks
-  rev: v2.7.0
+  rev: v2.11.0
   hooks:
   - id: pretty-format-yaml
     args: [--autofix]
@@ -20,15 +15,22 @@ repos:
     exclude: poetry.lock
     args: [--autofix]
 - repo: https://github.com/psf/black
-  rev: 23.1.0
+  rev: 23.10.0
   hooks:
   - id: black
-- repo: https://github.com/charliermarsh/ruff-pre-commit
-  rev: v0.0.249
+- repo: https://github.com/adamchainz/blacken-docs
+  rev: 1.16.0
+  hooks:
+  - id: blacken-docs
+    additional_dependencies:
+    - black==23.9.1
+- repo: https://github.com/astral-sh/ruff-pre-commit
+  rev: v0.1.1
   hooks:
   - id: ruff
+    args: [--fix]
 - repo: https://github.com/pre-commit/mirrors-mypy
-  rev: v1.0.1
+  rev: v1.6.1
   hooks:
   - id: mypy
     additional_dependencies: [types-requests, types-setuptools]

CHANGELOG.md

@@ -0,0 +1,130 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+<!-- start changelog -->
+
+## [v5](https://github.com/jeertmans/manim-slides/compare/v4.16.0...v5.0.0)
+
+Prior to v5, there was no real CHANGELOG other than the GitHub releases,
+with most of the content automatically generated by GitHub from merged
+pull requests.
+
+In an effort to better document changes, this CHANGELOG document is now created.
+
+(v5-added)=
+### Added
+
+- Added the following option aliases to `manim-slides present`:
+  `-F` and `--full-screen` for `fullscreen`,
+  `-H` for `--hide-mouse`,
+  and `-S` for `--screen-number`.
+  [#243](https://github.com/jeertmans/manim-slides/pull/243)
+- Added a full screen key binding (defaults to <kbd>F</kbd>) in the
+  presenter.
+  [#243](https://github.com/jeertmans/manim-slides/pull/243)
+- Added support for including code from a file in Manim Slides
+  Sphinx directive.
+  [#261](https://github.com/jeertmans/manim-slides/pull/261)
+- Added the `manim_slides.slide.animation` module and created the
+  `Wipe` and `Zoom` classes, that return a new animation.
+  [#285](https://github.com/jeertmans/manim-slides/pull/285)
+- Added two environ variables, `MANIM_API` and `FORCE_MANIM_API`,
+  to specify the `MANIM_API` to be used: `manim` and `manimce` will
+  import `manim`, while `manimgl` and `manimlib` will import `manimlib`.
+  If one of the two APIs is already imported, use `FORCE_MANIM_API=1` to
+  override this.
+  [#285](https://github.com/jeertmans/manim-slides/pull/285)
+- Added a working `ThreeDSlide` class compatible with `manimlib`.
+  [#285](https://github.com/jeertmans/manim-slides/pull/285)
+- Added `loop` option to `Slide`'s `next_slide` method.
+  Calling `next_slide` will never fail anymore.
+  [#294](https://github.com/jeertmans/manim-slides/pull/294)
+- Added `Slide.next_section` for compatibility with `manim`'s
+  `Scene.next_section` method.
+  [#295](https://github.com/jeertmans/manim-slides/pull/295)
+- Added `--next-terminates-loop` option to `manim-slides present` for turn a
+  looping slide into a normal one, so that it ends nicely. This is useful to
+  have a smooth transition with the next slide.
+  [#299](https://github.com/jeertmans/manim-slides/pull/299)
+- Added `--playback-rate` option to `manim-slides present` for testing purposes.
+  [#300](https://github.com/jeertmans/manim-slides/pull/300)
+- Added `auto_next` option to `Slide`'s `next_slide` method to automatically
+  play the next slide upon terminating. Supported by `present` and
+  `convert --to=html` commands.
+  [#304](https://github.com/jeertmans/manim-slides/pull/304)
+
+(v5-changed)=
+### Changed
+
+- Automatically concatenate all animations from a slide into one.
+  This is a **breaking change** because the config file format is
+  different from the previous one. For migration help, see associated PR.
+  [#242](https://github.com/jeertmans/manim-slides/pull/242)
+- Changed the player interface to only use PySide6, and not a combination of
+  PySide6 and OpenCV. A few features have been removed (see removed section),
+  but the new player should be much easier to maintain and more performant,
+  than its predecessor.
+  [#243](https://github.com/jeertmans/manim-slides/pull/243)
+- Changed the slide config format to exclude unecessary information.
+  `StypeType` is removed in favor to one boolean `loop` field. This is
+  a **breaking change** and one should re-render the slides to apply changes.
+  [#243](https://github.com/jeertmans/manim-slides/pull/243)
+- Renamed key bindings in the config. This is a **breaking change** and one
+  should either manually rename them (see list below) or re-init a config.
+  List of changes: `CONTINUE` to `NEXT`, `BACK` to `PREVIOUS`, and
+  `REWIND` to `REPLAY`.
+  [#243](https://github.com/jeertmans/manim-slides/pull/243)
+- Conversion to HTML now uses Jinja2 templating. The template file has
+  been modified accordingly, and old templates will not work anymore.
+  This is a **breaking change**.
+  [#271](https://github.com/jeertmans/manim-slides/pull/271)
+- Bumped RevealJS' default version to v4.6.1, and added three new themes.
+  [#272](https://github.com/jeertmans/manim-slides/pull/272)
+- Changed the logger such that `make_logger` is called at module import,
+  and we do not use Manim's logger anymore.
+  [#285](https://github.com/jeertmans/manim-slides/pull/285)
+- Changed `Slide.wipe` and `Slide.zoom` to automatically call `self.play`.
+  This is a **breaking change** as calling `self.play(self.wipe(...))` now
+  raises an error (because `None` is not an animation).
+  [#285](https://github.com/jeertmans/manim-slides/pull/285)
+- Changed the `manim_slides.slide` module to contain submodules, i.e.,
+  `slide.manim`, `slide.manimlib`, `slide.animation`.
+  Only `slide.animation` is part of the public API.
+  Rules for choosing the Manim API (either `manim` or `manimlib`) has changed,
+  and defaults to the currently imported module, with a preference for `manim`.
+  [#285](https://github.com/jeertmans/manim-slides/pull/285)
+
+(v5-fixed)=
+### Fixed
+
+- Patched enums in `manim_slides/convert.py` to correctly call `str`'s
+  `__str__` method, and not the `Enum` one.
+  This bug was discovered by
+  [@alexanderskulikov](https://github.com/alexanderskulikov) in
+  [#253](https://github.com/jeertmans/manim-slides/discussions/253), caused by
+  Python 3.11's change in how `Enum` work.
+  [#257](https://github.com/jeertmans/manim-slides/pull/257).
+- Fixed potential non-existing parent path issue in
+  `manim convert`'s destination path.
+  [#262](https://github.com/jeertmans/manim-slides/pull/262)
+
+(v5-removed)=
+### Removed
+
+- Removed `--start-at-animation-number` option from `manim-slides present`.
+  [#242](https://github.com/jeertmans/manim-slides/pull/242)
+- Removed the following options from `manim-slides present`:
+  `--resolution`, `--record-to`, `--resize-mode`, and `--background-color`.
+  [#243](https://github.com/jeertmans/manim-slides/pull/243)
+- Removed `PERF` verbosity level because not used anymore.
+  [#245](https://github.com/jeertmans/manim-slides/pull/245)
+- Remove `Slide`'s method `start_loop` and `self.end_loop`
+  in favor to `self.next_slide(loop=True)`.
+  This is a **breaking change**.
+  [#294](https://github.com/jeertmans/manim-slides/pull/294)
+
+<!-- end changelog -->

CITATION.cff

@@ -0,0 +1,32 @@
+# This CITATION.cff file was generated with cffinit.
+# Visit https://bit.ly/cffinit to generate yours today!
+
+cff-version: 1.2.0
+title: Manim Slides
+message: A Python package for presenting Manim content anywhere
+type: software
+authors:
+  - name: Jérome Eertmans
+    orcid: 'https://orcid.org/0000-0002-5579-5360'
+    website: 'https://eertmans.be'
+identifiers:
+  - type: doi
+    value: 10.21105/jose.00206
+    description: The paper presenting the software.
+repository-code: 'https://github.com/jeertmans/manim-slides'
+url: 'https://eertmans.be/manim-slides'
+abstract: >-
+  Manim Slides is a Python package that makes presenting
+  Manim animations straightforward. With minimal changes
+  required to pre-existing code, one can slide through
+
+  animations in a PowerPoint-like manner, or share its
+  slides online using ReavealJS’ power.
+keywords:
+  - Education
+  - Math Animations
+  - Presentation Tool
+  - PowerPoint
+  - Python
+license: MIT
+version: v5.0.0

README.md

@@ -1,8 +1,17 @@
-![Manim Slides Logo](https://raw.githubusercontent.com/jeertmans/manim-slides/main/static/logo.png)
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/jeertmans/manim-slides/main/static/logo_dark_transparent.png">
+  <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/jeertmans/manim-slides/main/static/logo_light_transparent.png">
+  <img alt="Manim Slides Logo" src="https://raw.githubusercontent.com/jeertmans/manim-slides/main/static/logo.png">
+</picture>
 
 [![Latest Release][pypi-version-badge]][pypi-version-url]
 [![Python version][pypi-python-version-badge]][pypi-version-url]
-![PyPI - Downloads](https://img.shields.io/pypi/dm/manim-slides)
+[![PyPI - Downloads][pypi-download-badge]][pypi-version-url]
+[![Documentation][documentation-badge]][documentation-url]
+[![DOI][doi-badge]][doi-url]
+[![JOSE Paper][jose-badge]][jose-url]
+[![codecov][codecov-badge]][codecov-url]
+
 # Manim Slides
 
 Tool for live presentations using either [Manim (community edition)](https://www.manim.community/) or [ManimGL](https://3b1b.github.io/manim/). Manim Slides will *automatically* detect the one you are using!
@@ -22,6 +31,9 @@ Tool for live presentations using either [Manim (community edition)](https://www
 - [F.A.Q](#faq)
   * [How to increase quality on Windows](#how-to-increase-quality-on-windows)
 - [Contributing](#contributing)
+  * [Reporting an Issue](#reporting-an-issue)
+  * [Seeking for Help](#seeking-for-help)
+  * [Contact](#contact)
 
 ## Installation
 
@@ -49,6 +61,16 @@ The recommended way to install the latest release is to use pip:
 pip install manim-slides
 ```
 
+Optionally, you can also install Manim or ManimGL using extras[^1]:
+
+```bash
+pip install manim-slides[manim]   # For Manim
+# or
+pip install manim-slides[manimgl] # For ManimGL
+```
+
+[^1]: NOTE: you still need to have Manim or ManimGL platform-specific dependencies installed on your computer.
+
 ### Install From Repository
 
 An alternative way to install Manim Slides is to clone the git repository, and install from there: read the [contributing guide](https://eertmans.be/manim-slides/contributing/workflow.html) to know how.
@@ -60,36 +82,38 @@ An alternative way to install Manim Slides is to clone the git repository, and i
 <!-- start usage -->
 
 Using Manim Slides is a two-step process:
-1. Render animations using `Slide` (resp. `ThreeDSlide`) as a base class instead of `Scene` (resp. `ThreeDScene`), and add calls to `self.pause()` everytime you want to create a new slide.
+1. Render animations using `Slide` (resp. `ThreeDSlide`) as a base class instead of `Scene` (resp. `ThreeDScene`), and add calls to `self.next_slide()` everytime you want to create a new slide.
 2. Run `manim-slides` on rendered animations and display them like a *Power Point* presentation.
 
 The documentation is available [online](https://eertmans.be/manim-slides/).
 
 ### Basic Example
 
-Wrap a series of animations between `self.start_loop()` and `self.stop_loop()` when you want to loop them (until input to continue):
+Call `self.next_slide()` everytime you want to create a pause between
+animations, and `self.next_slide(loop=True)` if you want the next slide to loop
+over animations until the user presses continue:
 
 ```python
 # example.py
 
-from manim import *
-# or: from manimlib import *
+from manim import *  # or: from manimlib import *
+
 from manim_slides import Slide
 
+
 class BasicExample(Slide):
     def construct(self):
         circle = Circle(radius=3, color=BLUE)
         dot = Dot()
 
         self.play(GrowFromCenter(circle))
-        self.pause()  # Waits user to press continue to go to the next slide
+        self.next_slide()  # Waits user to press continue to go to the next slide
 
-        self.start_loop()  # Start loop
+        self.next_slide(loop=True)  # Start loop
         self.play(MoveAlongPath(dot, circle), run_time=2, rate_func=linear)
-        self.end_loop()  # This will loop until user inputs a key
+        self.next_slide()  # This will start a new non-looping slide
 
         self.play(dot.animate.move_to(ORIGIN))
-        self.pause()  # Waits user to press continue to go to the next slide
 ```
 
 First, render the animation files:
@@ -118,7 +142,11 @@ manim-slides BasicExample
 
 The default key bindings to control the presentation are:
 
-![manim-wizard](https://user-images.githubusercontent.com/27275099/197468787-19c83a81-d757-47b9-8f68-218427d30298.png)
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/jeertmans/manim-slides/main/static/wizard_dark.png">
+  <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/jeertmans/manim-slides/main/static/wizard_light.png">
+  <img alt="Manim Slides Wizard" src="https://raw.githubusercontent.com/jeertmans/manim-slides/main/static/wizard_light.png">
+</picture>
 
 
 You can run the **configuration wizard** to change those key bindings:
@@ -181,6 +209,65 @@ in *Settings*->*Display*.
 
 Contributions are more than welcome! Please read through [our contributing section](https://eertmans.be/manim-slides/contributing/index.html).
 
+### Reporting an Issue
+
+<!-- start reporting-an-issue -->
+
+If you think you found a bug,
+an error in the documentation,
+or wish there was some feature that is currently missing,
+we would love to hear from you!
+
+The best way to reach us is via the
+[GitHub issues](https://github.com/jeertmans/manim-slides/issues).
+If your problem is not covered by an already existing (closed or open) issue,
+then we suggest you create a
+[new issue](https://github.com/jeertmans/manim-slides/issues/new/choose).
+You can choose from a list of templates, or open a
+[blank issue](https://github.com/jeertmans/manim-slides/issues/new)
+if your issue does not fit one of the proposed topics.
+
+The more precise you are in the description of your problem, the faster we will
+be able to help you!
+
+<!-- end reporting-an-issue -->
+
+### Seeking for help
+
+<!-- start seeking-for-help -->
+
+Sometimes, you may have a question about Manim Slides,
+not necessarily an issue.
+
+There are two ways you can reach us for questions:
+
+- via the `Question/Help/Support` topic when
+[choosing an issue template](https://github.com/jeertmans/manim-slides/issues/new/choose);
+- or via
+[GitHub discussions](https://github.com/jeertmans/manim-slides/discussions).
+
+<!-- end seeking-for-help -->
+
+### Contact
+
+<!-- start contact -->
+
+Finally, if you do not have any GitHub account,
+or just wish to contact the author of Manim Slides,
+you can do so at: [jeertmans@icloud.com](mailto:jeertmans@icloud.com).
+
+<!-- end contact -->
+
 [pypi-version-badge]: https://img.shields.io/pypi/v/manim-slides?label=manim-slides
 [pypi-version-url]: https://pypi.org/project/manim-slides/
 [pypi-python-version-badge]: https://img.shields.io/pypi/pyversions/manim-slides
+[pypi-download-badge]: https://img.shields.io/pypi/dm/manim-slides
+[documentation-badge]: https://img.shields.io/website?down_color=lightgrey&down_message=offline&label=documentation&up_color=green&up_message=online&url=https%3A%2F%2Feertmans.be%2Fmanim-slides%2F
+[documentation-url]: https://eertmans.be/manim-slides/
+[doi-badge]: https://zenodo.org/badge/DOI/10.5281/zenodo.8215167.svg
+[doi-url]: https://doi.org/10.5281/zenodo.8215167
+[jose-badge]: https://jose.theoj.org/papers/10.21105/jose.00206/status.svg
+[jose-url]: https://doi.org/10.21105/jose.00206
+
+[codecov-badge]: https://codecov.io/gh/jeertmans/manim-slides/branch/main/graph/badge.svg?token=8P4DY9JCE4
+[codecov-url]: https://codecov.io/gh/jeertmans/manim-slides

custom_config.yml

@@ -0,0 +1,2 @@
+style:
+  background_color: '#000000'

docs/source/_static/logo.png

@@ -0,0 +1 @@
+../../../static/logo.png

docs/source/_static/logo_dark_docs.png

@@ -0,0 +1 @@
+../../../static/logo_dark_docs.png

docs/source/_static/logo_dark_github.png

@@ -0,0 +1 @@
+../../../static/logo_dark_github.png

docs/source/_static/logo_dark_transparent.png

@@ -0,0 +1 @@
+../../../static/logo_dark_transparent.png

docs/source/_static/logo_light_transparent.png

@@ -0,0 +1 @@
+../../../static/logo_light_transparent.png

docs/source/_static/wizard_dark.png

@@ -0,0 +1 @@
+../../../static/wizard_dark.png

docs/source/_static/wizard_light.png

@@ -0,0 +1 @@
+../../../static/wizard_light.png

docs/source/changelog.md

@@ -1,3 +1,6 @@
 # Changelog
 
-Changes between releases are listed in Manim Slides' [Github releases](https://github.com/jeertmans/manim-slides/releases). You can read the [latest release here](https://github.com/jeertmans/manim-slides/releases).
+```{include} ../../CHANGELOG.md
+:start-after: <!-- start changelog -->
+:end-before: <!-- end changelog -->
+```

docs/source/conf.py

@@ -15,18 +15,32 @@ author = "Jérome Eertmans"
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
 
 extensions = [
+    # Built-in
     "sphinx.ext.autodoc",
     "sphinx.ext.intersphinx",
     "sphinx.ext.viewcode",
+    # Additional
+    "nbsphinx",
+    "myst_parser",
     "sphinxext.opengraph",
     "sphinx_click",
-    "myst_parser",
     "sphinx_copybutton",
+    # Custom
+    "manim_slides.docs.manim_slides_directive",
+]
+
+autodoc_typehints = "both"
+
+myst_enable_extensions = [
+    "colon_fence",
+    "html_admonition",
 ]
 
 templates_path = ["_templates"]
 exclude_patterns = []
 
+# Removes the 'package.module' part from package.module.Class
+add_module_names = False
 
 # -- Options for HTML output -------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
@@ -35,6 +49,8 @@ html_theme = "furo"
 html_static_path = ["_static"]
 
 html_theme_options = {
+    "light_logo": "logo_light_transparent.png",
+    "dark_logo": "logo_dark_transparent.png",
     "footer_icons": [
         {
             "name": "GitHub",
@@ -58,6 +74,7 @@ intersphinx_mapping = {
     "python": ("https://docs.python.org/3", None),
     "manim": ("https://docs.manim.community/en/stable/", None),
     "manimlib": ("https://3b1b.github.io/manim/", None),
+    "numpy": ("https://numpy.org/doc/stable/", None),
 }
 
 # -- OpenGraph settings

docs/source/contributing/index.md

@@ -2,10 +2,14 @@
 
 Thank you for your interest in Manim Slides! ✨
 
-Manim Slides is an open source project, first created as a fork of [manim-presentation](https://github.com/galatolofederico/manim-presentation) (now deprecated in favor to Manim Slides), and we welcome contributions of all forms.
-
-This section is here to help fist-time contributors know how they can help this project grow. Whether you are already familiar with Manim or GitHub, it is worth taking a few minutes to read those documents!
+Manim Slides is an open source project, first created as a fork of
+[manim-presentation](https://github.com/galatolofederico/manim-presentation)
+(now deprecated in favor to Manim Slides),
+and we welcome contributions of all forms.
 
+This section is here to help fist-time contributors know how they can help this
+project grow. Whether you are already familiar with Manim or GitHub,
+it is worth taking a few minutes to read those documents!
 
 ```{toctree}
 :hidden:
@@ -19,3 +23,24 @@ internals
 
 [Internals](./internals)
 : how Manim Slides is built and how the various parts of it work.
+
+## Reporting an Issue
+
+```{include} ../../../README.md
+:start-after: <!-- start reporting-an-issue -->
+:end-before: <!-- end reporting-an-issue -->
+```
+
+## Seeking for Help
+
+```{include} ../../../README.md
+:start-after: <!-- start seeking-for-help -->
+:end-before: <!-- end seeking-for-help -->
+```
+
+## Contact
+
+```{include} ../../../README.md
+:start-after: <!-- start contact -->
+:end-before: <!-- end contact -->
+```

docs/source/contributing/workflow.md

@@ -11,7 +11,7 @@ This document is there to help you recreate a working environment for Manim Slid
 
 ## Forking the repository and cloning it locally
 
-We used GitHub to host Manim Slides' repository, and we encourage contributors to use git.
+We use GitHub to host Manim Slides' repository, and we encourage contributors to use git.
 
 Useful links:
 
@@ -30,6 +30,32 @@ With Poetry, installation becomes straightforward:
 poetry install
 ```
 
+This, however, only installs the minimal set of dependencies to run the package.
+
+If you would like to install Manim or ManimGL, as documented in the [quickstart](../quickstart),
+you can use the `--extras` option:
+
+```bash
+poetry install --extras manim   # For Manim
+# or
+poetry install --extras manimgl # For ManimGL
+```
+
+Additionnally, Manim Slides comes with group dependencies for development purposes:
+
+```bash
+poetry install --with dev  # For linters and formatters
+# or
+poetry install --with docs # To build the documentation locally
+```
+
+Another group is `test`, but it is only used for
+[GitHub actions](https://github.com/jeertmans/manim-slides/blob/main/.github/workflows/test_examples.yml).
+
+:::{note}
+You can combine any number of groups or extras when installing the package locally.
+:::
+
 ## Running commands
 
 As modules were installed in a new Python environment, you cannot use them directly in the shell.
@@ -42,7 +68,7 @@ poetry run manim-slides wizard
 or enter a new shell that uses this new Python environment:
 
 ```
-poetry run
+poetry shell
 manim-slides wizard
 ```
 

docs/source/docutils.conf

@@ -0,0 +1,2 @@
+[restructuredtext parser]
+syntax_highlight = short

docs/source/features_table.md

@@ -0,0 +1,29 @@
+# Features Table
+
+The following summarizes the different presentation features Manim Slides offers.
+
+:::{table} Comparison of the different presentation methods.
+:widths: auto
+:align: center
+
+| Feature / Constraint | [`present`](reference/cli.md) | [`convert --to=html`](reference/cli.md) | [`convert --to=pptx`](reference/cli.md) | [`convert --to=pdf`](reference/cli.md)
+| :--- | :---: | :---: | :---: | :---: |
+| Basic navigation through slides | Yes | Yes | Yes | Yes (static image) |
+| Replay slide | Yes | No | No | N/A |
+| Pause animation | Yes | No | No | N/A |
+| Play slide in reverse | Yes | No | No | N/A |
+| Slide count | Yes | Yes (optional) | Yes (optional) | N/A |
+| Needs Python with Manim Slides installed | Yes | No | No | No
+| Requires internet access | No | Yes | No | No |
+| Auto. play slides | Yes | Yes | Yes | N/A |
+| Loops support | Yes | Yes | Yes | N/A |
+| Fully customizable | No | Yes (`--use-template` option) | No | No |
+| Other dependencies | None | A modern web browser | PowerPoint or LibreOffice Impress[^1] | None |
+| Works cross-platforms | Yes | Yes | Partly[^1][^2] | Yes |
+:::
+
+[^1]: If you encounter a problem where slides do not automatically play or loops do not work,
+  please
+  [file an issue on GitHub](https://github.com/jeertmans/manim-slides/issues/new/choose).
+[^2]: PowerPoint online does not seem to support automatic playing of videos,
+  so you need LibreOffice Impress on Linux platforms.

docs/source/index.md

@@ -4,9 +4,18 @@ og:description: Manim Slides makes creating slides with Manim super easy!
 ---
 
 ```{eval-rst}
-.. image:: _static/logo.png
+.. image:: _static/logo_light_transparent.png
     :width: 600px
     :align: center
+    :class: only-light
+    :alt: Manim Slide logo
+```
+
+```{eval-rst}
+.. image:: _static/logo_dark_transparent.png
+    :width: 600px
+    :align: center
+    :class: only-dark
     :alt: Manim Slide logo
 ```
 
@@ -14,22 +23,26 @@ og:description: Manim Slides makes creating slides with Manim super easy!
 
 Manim Slides makes creating slides with Manim super easy!
 
-In a [very few steps](./quickstart), you can create slides and present them either using the GUI, or your browser.
+In a [very few steps](./quickstart),
+you can create slides and present them either using the GUI, or your browser.
 
 
-Slide through the demo below to get a quick glimpse on what you can do with Manin Slides.
-
-
-<!-- From: https://faq.dailymotion.com/hc/en-us/articles/360022841393-How-to-preserve-the-player-aspect-ratio-on-a-responsive-page -->
-
-<div style="position:relative;padding-bottom:56.25%;"> <iframe style="width:100%;height:100%;position:absolute;left:0px;top:0px;" frameborder="0" width="100%" height="100%" allowfullscreen allow="autoplay" src="_static/slides.html"></iframe></div>
+Slide through the demo below to get a quick glimpse on what you can do with
+Manim Slides.
 
+```{eval-rst}
+.. manim-slides:: ../../example.py:ConvertExample
+    :hide_source:
+    :quality: high
+```
 
 ```{toctree}
 :hidden:
 
 quickstart
 reference/index
+features_table
+manim_or_manimgl
 ```
 
 ```{toctree}

docs/source/manim_or_manimgl.md

@@ -0,0 +1,71 @@
+# Manim or ManimGL
+
+Manim Slides supports both Manim (Community Edition) and ManimGL (by 3b1b).
+
+Because both modules have slightly different APIs, Manim Slides needs to know
+which Manim API you are using, to import the correct module.
+
+## Default Behavior
+
+By default, Manim Slides looks at {py:data}`sys.modules` and chooses the first
+Manim package that is already imported: `manim` for Manim,
+`manimlib` for ManimGL. This works pretty well when rendering
+the slides.
+
+If both modules are present in {py:data}`sys.modules`, then Manim Slides will
+prefer using `manim`.
+
+
+### Usage
+
+The simplest way to use Manim Slides with the correct Manim API is to:
+
+1. first import the Manim API;
+2. and, then, import `manim_slides`.
+
+Example for `manim`:
+
+```python
+from manim import *
+from manim_slides import Slide
+```
+
+Example for `manimlib`:
+
+```python
+from manimlib import *
+from manim_slides import Slide
+```
+
+### Example of Default Import
+
+The following code shows how Manim Slides detected that `manimlib`
+was imported, so the {py:class}`Slide<manim_slides.slide.Slide>`
+automatically subclasses the class from ManimGL, not Manim.
+
+```python
+from manimlib import Scene
+from manim_slides import Slide
+
+assert issubclass(Slide, Scene)  # Slide subclasses Scene from ManimGL
+
+from manim import Scene
+
+assert not issubclass(Slide, Scene)  # but not Scene from Manim
+```
+
+## Custom Manim API
+
+If you want to override the default Manim API, you can set the `MANIM_API`
+environment variable to:
+
+- `manim` or `manimce` to import `manim`;
+- `manimlib` or `manimgl` to import `manimlib`;
+
+prior to importing `manim_slides`.
+
+Note that Manim Slides will still first look at {py:data}`sys.modules` to check
+if any of the two modules is already imported.
+
+If you want to force Manim Slides to obey the `MANIM_API` environment variable,
+you must also set `FORCE_MANIM_API=1`.

docs/source/quickstart.md

@@ -16,6 +16,10 @@
 
 The output slides should look this this:
 
-<div style="position:relative;padding-bottom:56.25%;"> <iframe style="width:100%;height:100%;position:absolute;left:0px;top:0px;" frameborder="0" width="100%" height="100%" allowfullscreen allow="autoplay" src="_static/basic_example.html"></iframe></div>
+```{eval-rst}
+.. manim-slides:: ../../example.py:BasicExample
+    :hide_source:
+    :quality: high
+```
 
 For more advanced examples, see the [Examples](reference/examples) section.

docs/source/reference/api.md

@@ -1,13 +1,40 @@
 # Application Programming Interface
 
-Manim Slides' API is very limited: it simply consists in two classes, `Slide` and `ThreeDSlide`, which are subclasses of `Scene` and `ThreeDScene` from Manim.
+Manim Slides' API is very limited: it simply consists of two classes, `Slide`
+and `ThreeDSlide`, which are subclasses of `Scene` and `ThreeDScene` from Manim.
 
-Thefore, we only document here the methods we think the end-user will ever use, not the methods used internally when rendering.
+Therefore, we only document here the methods we think the end-user will ever
+use, not the methods used internally when rendering.
+
+## Slide
 
 ```{eval-rst}
-.. autoclass:: manim_slides.Slide
-    :members: start_loop, end_loop, pause, play
+.. autoclass:: manim_slides.slide.Slide
+    :members:
+        add_to_canvas,
+        canvas,
+        canvas_mobjects,
+        mobjects_without_canvas,
+        next_section,
+        next_slide,
+        remove_from_canvas,
+        wait_time_between_slides,
+        wipe,
+        zoom,
+```
 
-.. autoclass:: manim_slides.ThreeDSlide
+## 3D Slide
+
+```{eval-rst}
+.. autoclass:: manim_slides.slide.ThreeDSlide
     :members:
 ```
+
+## Animations
+
+```{eval-rst}
+.. automodule:: manim_slides.slide.animation
+    :members:
+        Wipe,
+        Zoom,
+```

docs/source/reference/examples.md

@@ -29,9 +29,11 @@ where `-ccontrols=true` indicates that we want to display the blue navigation ar
 
 Basic example from quickstart.
 
-<div style="position:relative;padding-bottom:56.25%;"> <iframe style="width:100%;height:100%;position:absolute;left:0px;top:0px;" frameborder="0" width="100%" height="100%" allowfullscreen allow="autoplay" src="../_static/basic_example.html"></iframe></div>
-
 ```{eval-rst}
+.. manim-slides:: ../../../example.py:BasicExample
+    :hide_source:
+    :quality: high
+
 .. literalinclude:: ../../../example.py
    :language: python
    :linenos:
@@ -40,13 +42,16 @@ Basic example from quickstart.
 
 ## 3D Example
 
-Example using 3D camera. As Manim and ManimGL handle 3D differently, definitions are slightly different.
-
-<div style="position:relative;padding-bottom:56.25%;"> <iframe style="width:100%;height:100%;position:absolute;left:0px;top:0px;" frameborder="0" width="100%" height="100%" allowfullscreen allow="autoplay" src="../_static/three_d_example.html"></iframe></div>
+Example using 3D camera. As Manim and ManimGL handle 3D differently,
+definitions are slightly different.
 
 ### With Manim
 
 ```{eval-rst}
+.. manim-slides:: ../../../example.py:ThreeDExample
+    :hide_source:
+    :quality: high
+
 .. literalinclude:: ../../../example.py
    :language: python
    :linenos:
@@ -66,13 +71,100 @@ Example using 3D camera. As Manim and ManimGL handle 3D differently, definitions
    :end-before: [manimgl-3d]
 ```
 
+## Subclass Custom Scenes
+
+For compatibility reasons, Manim Slides only provides subclasses for
+`Scene` and `ThreeDScene`.
+However, subclassing other scene classes is totally possible,
+and very simple to do actually!
+
+[For example](https://github.com/jeertmans/manim-slides/discussions/185),
+you can subclass the `MovingCameraScene` class from `manim`
+with the following code:
+
+```{code-block} python
+:linenos:
+
+from manim import *
+from manim_slides import Slide
+
+
+class MovingCameraSlide(Slide, MovingCameraScene):
+    pass
+```
+
+And later use this class anywhere in your code:
+
+
+```{code-block} python
+:linenos:
+
+class SubclassExample(MovingCameraSlide):
+    """Example taken from ManimCE's docs."""
+
+    def construct(self):
+        self.camera.frame.save_state()
+
+        ax = Axes(x_range=[-1, 10], y_range=[-1, 10])
+        graph = ax.plot(lambda x: np.sin(x), color=WHITE, x_range=[0, 3 * PI])
+
+        dot_1 = Dot(ax.i2gp(graph.t_min, graph))
+        dot_2 = Dot(ax.i2gp(graph.t_max, graph))
+        self.add(ax, graph, dot_1, dot_2)
+
+        self.play(self.camera.frame.animate.scale(0.5).move_to(dot_1))
+        self.next_slide()
+        self.play(self.camera.frame.animate.move_to(dot_2))
+        self.next_slide()
+        self.play(Restore(self.camera.frame))
+        self.wait()
+```
+
+:::{note}
+If you do not plan to reuse `MovingCameraSlide` more than once, then you can
+directly write the `construct` method in the body of `MovingCameraSlide`.
+:::
+
+```{eval-rst}
+.. manim-slides:: SubclassExample
+    :hide_source:
+    :quality: high
+
+    from manim import *
+    from manim_slides import Slide
+
+
+    class MovingCameraSlide(Slide, MovingCameraScene):
+        pass
+
+    class SubclassExample(MovingCameraSlide):
+        def construct(self):
+            self.camera.frame.save_state()
+
+            ax = Axes(x_range=[-1, 10], y_range=[-1, 10])
+            graph = ax.plot(lambda x: np.sin(x), color=WHITE, x_range=[0, 3 * PI])
+
+            dot_1 = Dot(ax.i2gp(graph.t_min, graph))
+            dot_2 = Dot(ax.i2gp(graph.t_max, graph))
+            self.add(ax, graph, dot_1, dot_2)
+
+            self.play(self.camera.frame.animate.scale(0.5).move_to(dot_1))
+            self.next_slide()
+            self.play(self.camera.frame.animate.move_to(dot_2))
+            self.next_slide()
+            self.play(Restore(self.camera.frame))
+            self.wait()
+```
+
 ## Advanced Example
 
 A more advanced example is `ConvertExample`, which is used as demo slide and tutorial.
 
-<div style="position:relative;padding-bottom:56.25%;"> <iframe style="width:100%;height:100%;position:absolute;left:0px;top:0px;" frameborder="0" width="100%" height="100%" allowfullscreen allow="autoplay" src="../_static/slides.html"></iframe></div>
-
 ```{eval-rst}
+.. manim-slides:: ../../../example.py:ConvertExample
+    :hide_source:
+    :quality: high
+
 .. literalinclude:: ../../../example.py
    :language: python
    :linenos:

docs/source/reference/gui.md

@@ -0,0 +1,71 @@
+# Graphical User Interface
+
+Manim Slides' graphical user interface (GUI) is the *de facto* way to present slides.
+
+If you do not specify one of the commands listed in the [CLI reference](./cli),
+Manim Slides will use **present** by default, which launches a GUI window,
+playing your scene(s) like so:
+
+```bash
+manim-slides [present] [SCENES]...
+```
+
+Some optional parameters can be specified and can be listed with:
+
+```bash
+manim-slides present --help
+```
+
+:::{note}
+All the `SCENES` must be in the same folder (`--folder DIRECTORY`), which
+defaults to `./slides`. If you rendered your animations without changing
+directory, you should not worry about that :-)
+:::
+
+## Configuration File
+
+It is possible to configure Manim Slides via a configuration file, even though
+this feature is currently limited. You may initiliaze the default configuration
+file with:
+
+```bash
+manim-slides init
+```
+
+:::{warning}
+Note that, by default, Manim Slides will use default key bindings that are
+platform-dependent. If you decide to overwrite those with a config file, you may
+encounter some problems from platform to platform.
+:::
+
+## Configuring Key Bindings
+
+If you wish to use other key bindings than the defaults, you can run the
+configuration wizard with:
+
+```bash
+manim-slides wizard
+```
+
+A similar window to the image below will pop up and prompt to change keys.
+
+```{eval-rst}
+.. image:: ../_static/wizard_light.png
+    :width: 300px
+    :align: center
+    :class: only-light
+    :alt: Manim Slide Wizard
+```
+
+```{eval-rst}
+.. image:: ../_static/wizard_dark.png
+    :width: 300px
+    :align: center
+    :class: only-dark
+    :alt: Manim Slide Wizard
+```
+
+:::{note}
+Even though it is not currently supported through the GUI, you can select
+multiple key binding for the same action by modifying the config file.
+:::

docs/source/reference/html.md

@@ -0,0 +1,40 @@
+# HTML Presentations
+
+Manim Slides allows you to convert presentations into one HTML file, with
+[RevealJS](https://revealjs.com/). This file can then be opened with any modern
+web browser, allowing for a nice portability of your presentations.
+
+As with every command with Manim Slides, converting slides' fragments into one
+HTML file (and its assets) can be done in one command:
+
+```bash
+manim-slides convert [SCENES]... DEST
+```
+
+where `DEST` is the `.html` destination file.
+
+## Configuring the Template
+
+Many configuration options are available through the `-c<option>=<value>` syntax.
+Most, if not all, RevealJS options should be available by default. If that is
+not the case, please
+[fill an issue](https://github.com/jeertmans/manim-slides/issues/new/choose)
+on GitHub.
+
+You can print the list of available options with:
+
+```bash
+manim-slides convert --show-config
+```
+
+## Using a Custom Template
+
+The default template used for HTML conversion can be found on
+[GitHub](https://github.com/jeertmans/manim-slides/blob/main/manim_slides/data/revealjs_template.html)
+or printed with the `--show-template` option.
+If you wish to use another template, you can do so with the
+`--use-template FILE` option.
+
+## More about HTML Slides
+
+You can read more about HTML slides in the [sharing](./sharing) section.

docs/source/reference/index.md

@@ -8,13 +8,30 @@ Automatically generated reference for Manim Slides.
 api
 cli
 examples
+gui
+html
+IPython magic <ipython_magic>
 sharing
+Sphinx Extension <sphinx_extension>
 ```
 
-[Application Programming Interface](./api): list of classes and methods that may be useful to the end-user.
+[Application Programming Interface](./api): list of classes and methods that may
+be useful to the end-user.
 
-[Command Line Interface](./cli): list of all commands available using Manim Slides' executable.
+[Command Line Interface](./cli): list of all commands available using Manim
+Slides' executable.
 
 [Examples](./examples): curated list of examples and their output.
 
+[Graphical User Interface](./gui): details about the main Manim Slide' feature.
+
+[HTML Presentation](./html): an alternative way of presenting your animations.
+
+[IPython Magic](./ipython_magic): a magic to render and display Manim Slides inside notebooks.
+
++ [Example](./magic_example): example notebook using the magics.
+
 [Sharing](./sharing): how to share your presentation with others.
+
+
+[Sphinx Extension](./sphinx_extension): a Sphinx extension for diplaying Manim Slides animations within your documentation.

docs/source/reference/ipython_magic.md

@@ -0,0 +1,6 @@
+# Manim Slides' IPython magic
+
+```{eval-rst}
+.. automodule:: manim_slides.ipython.ipython_magic
+   :members: ManimSlidesMagic
+```

docs/source/reference/magic_example.ipynb

@@ -0,0 +1,99 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "6896875b-34ce-4fc5-809c-669c295067e7",
+   "metadata": {},
+   "source": [
+    "# Jupyter Magic Example\n",
+    "\n",
+    "This small example shows how to use the Manim Slides cell (`%%manim_slides`) and line (`%manim_slides`) magics:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a73f1c06-c7f8-4f19-a90e-e283bfb8c7c5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from manim import *\n",
+    "from manim_slides import *"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "68dda1a0-74ff-4d9e-9575-5b25a98f21e7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%manim_slides -v WARNING --progress_bar None MySlide --manim-slides controls=true\n",
+    "\n",
+    "config.media_embed = True\n",
+    "\n",
+    "class MySlide(Slide):\n",
+    "    def construct(self):\n",
+    "        square = Square()\n",
+    "        circle = Circle()\n",
+    "        \n",
+    "        self.play(Create(square))\n",
+    "        self.next_slide()\n",
+    "        self.play(Transform(square, circle))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "54fa2d3e-bfee-417d-b64b-f3f30a8749ea",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class MyOtherSlide(Slide):\n",
+    "    def construct(self):\n",
+    "        text = VGroup(\n",
+    "            Text(\"Press\"),\n",
+    "            Text(\"and\"),\n",
+    "            Text(\"loop\"),\n",
+    "        ).arrange(DOWN, buff=1.)\n",
+    "        \n",
+    "        self.play(Write(text))\n",
+    "        self.next_slide(loop=True)\n",
+    "        self.play(Indicate(text[-1], scale_factor=2., run_time=.5))\n",
+    "        self.next_slide()\n",
+    "        self.play(FadeOut(text))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7d8ad450-1487-4ca7-8d89-bf8ac344e1fa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%manim_slides -v WARNING --progress_bar None MyOtherSlide --manim-slides controls=true"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "manim-slides",
+   "language": "python",
+   "name": "manim-slides"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/source/reference/sharing.md

@@ -67,7 +67,7 @@ and the corresponding tree:
 ## Without Manim Slides installed on the target machine
 
 An alternative to `manim-slides present` is `manim-slides convert`.
-Currently, only HTML conversion is available, but do not hesitate to propose
+Currently, HTML and PPTX conversion are available, but do not hesitate to propose
 other formats by creating a
 [Feature Request](https://github.com/jeertmans/manim-slides/issues/new/choose),
 or directly proposing a
@@ -131,19 +131,63 @@ and it there to preserve the original aspect ratio (16:9).
 
 ### Sharing ONE HTML file
 
-A future feature, that will be available once
-[#122](https://github.com/jeertmans/manim-slides/issues/122) is solved, will be
-to include all animations as data URI encoded, within the HTML file itself.
+If you set the `data_uri` option to `true` (with `-cdata_uri=true`),
+all animations will be data URI encoded, making the HTML a self-contained
+presentation file that can be shared on its own.
 
 ### Over the internet
 
-Finally, HTML conversion makes it convenient to play your presentation on a
+HTML conversion makes it convenient to play your presentation on a
 remote server.
 
 This is how your are able to watch all the examples on this website. If you want
 to know how to share your slide with GitHub pages, see the
 [workflow file](https://github.com/jeertmans/manim-slides/blob/main/.github/workflows/pages.yml).
 
-> **WARNING:** keep in minde that playing large video files over the internet
+> **WARNING:** keep in mind that playing large video files over the internet
 can take some time, and *glitches* may occur between slide transitions for this
 reason.
+
+
+### Using the Github starter template
+
+A [starter template](https://github.com/jeertmans/manim-slides-starter) is
+available which allows to quickly get going with a new Manim slides
+presentation on your Github account. The template comes ready with
+functionality to automate tasks using Github actions and publish to Github
+Pages. Please refer to the template page for usage instructions.
+
+### With PowerPoint (*EXPERIMENTAL*)
+
+A recent conversion feature is to the PowerPoint format, thanks to the
+`python-pptx` package. Even though it is fully working,
+it is still considered in an *EXPERIMENTAL* status because we do not
+exactly know what versions of PowerPoint (or LibreOffice Impress) are supported.
+
+Basically, you can create a PowerPoint in a single command:
+
+```bash
+manim-slides convert --to=pptx BasicExample basic_example.pptx
+```
+
+All the videos and necessary files will be contained inside the `.pptx` file, so
+you can safely share it with anyone. By default, the `poster_frame_image`, i.e.,
+what is displayed by PowerPoint when the video is not playing, is the first
+frame of each slide. This allows for smooth transitions.
+
+In the future, we hope to provide more features to this format,
+so feel free to suggest new features too!
+
+### Static PDF presentation
+
+If you ever need backup slides, that are only made of PDF pages
+with static images, you can generate such a PDF with the following command:
+
+```bash
+manim-slides convert --to=pdf BasicExample basic_example.pdf
+```
+
+Note that you will lose all the benefits from animated slides. Therefore,
+this is only recommended to be used as a backup plan. By default, the last frame
+of each slide will be printed. This can be changed to be the first one with
+`-cframe_index=first`.

docs/source/reference/sphinx_extension.md

@@ -0,0 +1,6 @@
+# Manim Slides' Sphinx directive
+
+```{eval-rst}
+.. automodule:: manim_slides.docs.manim_slides_directive
+   :members: ManimSlidesDirective
+```

example.py

@@ -1,19 +1,13 @@
 # flake8: noqa: F403, F405
 # type: ignore
-import sys
-
-if "manim" in sys.modules:
-    from manim import *
-
-    MANIMGL = False
-elif "manimlib" in sys.modules:
-    from manimlib import *
-
-    MANIMGL = True
-else:
-    raise ImportError("This script must be run with either `manim` or `manimgl`")
 
 from manim_slides import Slide, ThreeDSlide
+from manim_slides.slide import MANIM, MANIMGL
+
+if MANIM:
+    from manim import *
+elif MANIMGL:
+    from manimlib import *
 
 
 class BasicExample(Slide):
@@ -22,41 +16,20 @@ class BasicExample(Slide):
         dot = Dot()
 
         self.play(GrowFromCenter(circle))
-        self.pause()  # Waits user to press continue to go to the next slide
 
-        self.start_loop()  # Start loop
+        self.next_slide(loop=True)
         self.play(MoveAlongPath(dot, circle), run_time=2, rate_func=linear)
-        self.end_loop()  # This will loop until user inputs a key
+        self.next_slide()
 
         self.play(dot.animate.move_to(ORIGIN))
-        self.pause()  # Waits user to press continue to go to the next slide
-
-
-class TestFileTooLong(Slide):
-    """This is used to check against solution for issue #123."""
-
-    def construct(self):
-        import random
-
-        circle = Circle(radius=3, color=BLUE)
-        dot = Dot()
-        self.play(GrowFromCenter(circle), run_time=0.1)
-
-        for _ in range(30):
-            direction = (random.random() - 0.5) * LEFT + (random.random() - 0.5) * UP
-            self.play(dot.animate.move_to(direction), run_time=0.1)
-            self.play(dot.animate.move_to(ORIGIN), run_time=0.1)
-
-        self.pause()
 
 
 class ConvertExample(Slide):
     """WARNING: this example does not seem to work with ManimGL."""
 
-    def tinywait(self):
-        self.wait(0.1)
-
     def construct(self):
+        self.wait_time_between_slides = 0.1
+
         title = VGroup(
             Text("From Manim animations", t2c={"From": BLUE}),
             Text("to slides presentation", t2c={"to": BLUE}),
@@ -77,7 +50,7 @@ class ConvertExample(Slide):
 
         self.play(FadeIn(title))
 
-        self.pause()
+        self.next_slide()
 
         code = Code(
             code="""from manim import *
@@ -146,10 +119,10 @@ class Example(Slide):
         self.add(dot)
 
         self.play(Indicate(dot, scale_factor=2))
-        self.pause()
+        self.next_slide()
         square = Square()
         self.play(Transform(dot, square))
-        self.pause()
+        self.next_slide()
         self.play(Rotate(square, angle=PI/2))
 """,
             language="python",
@@ -163,12 +136,12 @@ class Example(Slide):
     def construct(self):
         dot = Dot()
         self.add(dot)
-        self.start_loop()
+        self.next_slide(loop=True)
         self.play(Indicate(dot, scale_factor=2))
-        self.end_loop()
+        self.next_slide()
         square = Square()
         self.play(Transform(dot, square))
-        self.pause()
+        self.next_slide()
         self.play(Rotate(square, angle=PI/2))
 """,
             language="python",
@@ -191,65 +164,53 @@ class Example(Slide):
             language="console",
         ).shift(DOWN)
 
-        self.clear()
-
-        self.play(FadeIn(code))
-        self.tinywait()
-        self.pause()
+        self.wipe(title, code)
+        self.next_slide()
 
         self.play(FadeIn(step, shift=RIGHT))
         self.play(Transform(code, code_step_1))
-        self.tinywait()
-        self.pause()
+        self.next_slide()
 
         self.play(Transform(step, step_2))
         self.play(Transform(code, code_step_2))
-        self.tinywait()
-        self.pause()
+        self.next_slide()
 
         self.play(Transform(step, step_3))
         self.play(Transform(code, code_step_3))
-        self.tinywait()
-        self.pause()
+        self.next_slide()
 
         self.play(Transform(step, step_4))
         self.play(Transform(code, code_step_4))
-        self.tinywait()
-        self.pause()
+        self.next_slide()
 
         self.play(Transform(step, step_5))
         self.play(Transform(code, code_step_5))
-        self.tinywait()
-        self.pause()
+        self.next_slide(auto_next=True)
 
         self.play(Transform(step, step_6))
         self.play(Transform(code, code_step_6))
         self.play(code.animate.shift(UP), FadeIn(code_step_7), FadeIn(or_text))
-        self.tinywait()
-        self.pause()
 
         watch_text = Text("Watch result on next slides!").shift(2 * DOWN).scale(0.5)
 
-        self.start_loop()
+        self.next_slide(loop=True)
         self.play(FadeIn(watch_text))
         self.play(FadeOut(watch_text))
-        self.end_loop()
+        self.next_slide()
         self.clear()
 
         dot = Dot()
         self.add(dot)
-        self.start_loop()
+        self.next_slide(loop=True)
         self.play(Indicate(dot, scale_factor=2))
-        self.end_loop()
+        self.next_slide()
         square = Square()
         self.play(Transform(dot, square))
         self.remove(dot)
         self.add(square)
-        self.tinywait()
-        self.pause()
+        self.next_slide()
         self.play(Rotate(square, angle=PI / 4))
-        self.tinywait()
-        self.pause()
+        self.next_slide()
 
         learn_more_text = (
             VGroup(
@@ -261,7 +222,6 @@ class Example(Slide):
         )
 
         self.play(Transform(square, learn_more_text))
-        self.tinywait()
 
 
 # For ThreeDExample, things are different
@@ -281,24 +241,24 @@ if not MANIMGL:
             self.play(GrowFromCenter(circle))
             self.begin_ambient_camera_rotation(rate=75 * DEGREES / 4)
 
-            self.pause()
+            self.next_slide()
 
-            self.start_loop()
+            self.next_slide(loop=True)
             self.play(MoveAlongPath(dot, circle), run_time=4, rate_func=linear)
-            self.end_loop()
+            self.next_slide()
 
             self.stop_ambient_camera_rotation()
             self.move_camera(phi=75 * DEGREES, theta=30 * DEGREES)
 
             self.play(dot.animate.move_to(ORIGIN))
-            self.pause()
+            self.next_slide()
 
             self.play(dot.animate.move_to(RIGHT * 3))
-            self.pause()
+            self.next_slide()
 
-            self.start_loop()
+            self.next_slide(loop=True)
             self.play(MoveAlongPath(dot, circle), run_time=2, rate_func=linear)
-            self.end_loop()
+            self.next_slide()
 
             self.play(dot.animate.move_to(ORIGIN))
 
@@ -307,11 +267,7 @@ else:
     # [manimgl-3d]
     # WARNING: 3b1b's manim change how ThreeDScene work,
     # this is why things have to be managed differently.
-    class ThreeDExample(Slide):
-        CONFIG = {
-            "camera_class": ThreeDCamera,
-        }
-
+    class ThreeDExample(ThreeDSlide):
         def construct(self):
             axes = ThreeDAxes()
             circle = Circle(radius=3, color=BLUE)
@@ -323,30 +279,32 @@ else:
             frame.set_euler_angles(
                 theta=30 * DEGREES,
                 phi=75 * DEGREES,
-                gamma=0,
             )
 
             self.play(GrowFromCenter(circle))
-            updater = lambda m, dt: m.increment_theta((75 * DEGREES / 4) * dt)
+
+            def updater(m, dt):
+                return m.increment_theta((75 * DEGREES / 4) * dt)
+
             frame.add_updater(updater)
 
-            self.pause()
+            self.next_slide()
 
-            self.start_loop()
+            self.next_slide(loop=True)
             self.play(MoveAlongPath(dot, circle), run_time=4, rate_func=linear)
-            self.end_loop()
+            self.next_slide()
 
             frame.remove_updater(updater)
             self.play(frame.animate.set_theta(30 * DEGREES))
             self.play(dot.animate.move_to(ORIGIN))
-            self.pause()
+            self.next_slide()
 
             self.play(dot.animate.move_to(RIGHT * 3))
-            self.pause()
+            self.next_slide()
 
-            self.start_loop()
+            self.next_slide(loop=True)
             self.play(MoveAlongPath(dot, circle), run_time=2, rate_func=linear)
-            self.end_loop()
+            self.next_slide()
 
             self.play(dot.animate.move_to(ORIGIN))
 

manim_slides/__init__.py

@@ -1,3 +1,61 @@
-# flake8: noqa: F401
+import sys
+from types import ModuleType
+from typing import Any, List
+
 from .__version__ import __version__
-from .slide import Slide, ThreeDSlide
+
+
+class Module(ModuleType):
+    def __getattr__(self, name: str) -> Any:
+        if name == "Slide" or name == "ThreeDSlide":
+            module = __import__(
+                "manim_slides.slide", None, None, ["Slide", "ThreeDSlide"]
+            )
+            return getattr(module, name)
+        elif name == "ManimSlidesMagic":
+            module = __import__(
+                "manim_slides.ipython.ipython_magic", None, None, ["ManimSlidesMagic"]
+            )
+            magic = getattr(module, name)
+
+            from IPython import get_ipython
+
+            ipy = get_ipython()
+
+            if ipy is not None:
+                ipy.register_magics(magic)
+
+            return magic
+
+        return ModuleType.__getattribute__(self, name)
+
+    def __dir__(self) -> List[str]:
+        result = list(new_module.__all__)
+        result.extend(
+            (
+                "__file__",
+                "__doc__",
+                "__all__",
+                "__docformat__",
+                "__name__",
+                "__path__",
+                "__package__",
+                "__version__",
+            )
+        )
+        return result
+
+
+old_module = sys.modules["manim_slides"]
+new_module = sys.modules["manim_slides"] = Module("manim_slides")
+
+new_module.__dict__.update(
+    {
+        "__file__": __file__,
+        "__package__": "manim_slides",
+        "__path__": __path__,
+        "__doc__": __doc__,
+        "__version__": __version__,
+        "__all__": ("__version__", "ManimSlidesMagic", "Slide", "ThreeDSlide"),
+    }
+)

manim_slides/__main__.py

@@ -4,9 +4,9 @@ import click
 import requests
 from click_default_group import DefaultGroup
 
-from . import __version__
+from .__version__ import __version__
 from .convert import convert
-from .manim import logger
+from .logger import logger
 from .present import list_scenes, present
 from .wizard import init, wizard
 

manim_slides/__version__.py

@@ -1 +1 @@
-__version__ = "4.9.2"
+__version__ = "5.0.0"

manim_slides/commons.py

@@ -5,14 +5,14 @@ import click
 from click import Context, Parameter
 
 from .defaults import CONFIG_PATH, FOLDER_PATH
-from .manim import logger
+from .logger import logger
 
 F = Callable[..., Any]
 Wrapper = Callable[[F], F]
 
 
 def config_path_option(function: F) -> F:
-    """Wraps a function to add configuration path option."""
+    """Wrap a function to add configuration path option."""
     wrapper: Wrapper = click.option(
         "-c",
         "--config",
@@ -27,7 +27,7 @@ def config_path_option(function: F) -> F:
 
 
 def config_options(function: F) -> F:
-    """Wraps a function to add configuration options."""
+    """Wrap a function to add configuration options."""
     function = config_path_option(function)
     function = click.option(
         "-f", "--force", is_flag=True, help="Overwrite any existing configuration file."
@@ -42,9 +42,9 @@ def config_options(function: F) -> F:
 
 
 def verbosity_option(function: F) -> F:
-    """Wraps a function to add verbosity option."""
+    """Wrap a function to add verbosity option."""
 
-    def callback(ctx: Context, param: Parameter, value: bool) -> None:
+    def callback(ctx: Context, param: Parameter, value: str) -> None:
         if not value or ctx.resilient_parsing:
             return
 
@@ -57,7 +57,7 @@ def verbosity_option(function: F) -> F:
             ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
             case_sensitive=False,
         ),
-        help="Verbosity of CLI output",
+        help="Verbosity of CLI output.",
         default=None,
         expose_value=False,
         envvar="MANIM_SLIDES_VERBOSITY",
@@ -69,7 +69,7 @@ def verbosity_option(function: F) -> F:
 
 
 def folder_path_option(function: F) -> F:
-    """Wraps a function to add folder path option."""
+    """Wrap a function to add folder path option."""
     wrapper: Wrapper = click.option(
         "--folder",
         metavar="DIRECTORY",

manim_slides/config.py

@@ -1,52 +1,57 @@
-import hashlib
-import os
+import json
 import shutil
-import subprocess
-import tempfile
-from enum import Enum
 from pathlib import Path
-from typing import Dict, List, Optional, Set, Union
+from typing import Any, Callable, Dict, List, Optional, Set, Tuple
 
-from pydantic import BaseModel, FilePath, root_validator, validator
+import rtoml
+from pydantic import (
+    BaseModel,
+    Field,
+    FilePath,
+    PositiveInt,
+    PrivateAttr,
+    field_validator,
+    model_validator,
+)
+from pydantic_extra_types.color import Color
 from PySide6.QtCore import Qt
 
-from .manim import FFMPEG_BIN, logger
+from .logger import logger
+
+Receiver = Callable[..., Any]
 
 
-def merge_basenames(files: List[FilePath]) -> Path:
-    """
-    Merge multiple filenames by concatenating basenames.
-    """
-    logger.info(f"Generating a new filename for animations: {files}")
+class Signal(BaseModel):  # type: ignore[misc]
+    __receivers: List[Receiver] = PrivateAttr(default_factory=list)
 
-    dirname = files[0].parent
-    ext = files[0].suffix
+    def connect(self, receiver: Receiver) -> None:
+        self.__receivers.append(receiver)
 
-    basenames = (file.stem for file in files)
+    def disconnect(self, receiver: Receiver) -> None:
+        self.__receivers.remove(receiver)
 
-    basenames_str = ",".join(f"{len(b)}:{b}" for b in basenames)
-
-    # We use hashes to prevent too-long filenames, see issue #123:
-    # https://github.com/jeertmans/manim-slides/issues/123
-    basename = hashlib.sha256(basenames_str.encode()).hexdigest()
-
-    return dirname / (basename + ext)
+    def emit(self, *args: Any) -> None:
+        for receiver in self.__receivers:
+            receiver(*args)
 
 
-class Key(BaseModel):  # type: ignore
+class Key(BaseModel):  # type: ignore[misc]
     """Represents a list of key codes, with optionally a name."""
 
-    ids: Set[int]
+    ids: List[PositiveInt] = Field(unique=True)
     name: Optional[str] = None
 
-    def set_ids(self, *ids: int) -> None:
-        self.ids = set(ids)
+    __signal: Signal = PrivateAttr(default_factory=Signal)
 
-    @validator("ids", each_item=True)
-    def id_is_posint(cls, v: int) -> int:
-        if v < 0:
-            raise ValueError("Key ids cannot be negative integers")
-        return v
+    @field_validator("ids")
+    @classmethod
+    def ids_is_non_empty_set(cls, ids: Set[Any]) -> Set[Any]:
+        if len(ids) <= 0:
+            raise ValueError("Key's ids must be a non-empty set")
+        return ids
+
+    def set_ids(self, *ids: int) -> None:
+        self.ids = list(set(ids))
 
     def match(self, key_id: int) -> bool:
         m = key_id in self.ids
@@ -56,71 +61,100 @@ class Key(BaseModel):  # type: ignore
 
         return m
 
+    @property
+    def signal(self) -> Signal:
+        return self.__signal
 
-class Config(BaseModel):  # type: ignore
-    """General Manim Slides config"""
+    def connect(self, function: Receiver) -> None:
+        self.__signal.connect(function)
 
+
+class Keys(BaseModel):  # type: ignore[misc]
     QUIT: Key = Key(ids=[Qt.Key_Q], name="QUIT")
-    CONTINUE: Key = Key(ids=[Qt.Key_Right], name="CONTINUE / NEXT")
-    BACK: Key = Key(ids=[Qt.Key_Left], name="BACK")
-    REVERSE: Key = Key(ids=[Qt.Key_V], name="REVERSE")
-    REWIND: Key = Key(ids=[Qt.Key_R], name="REWIND")
     PLAY_PAUSE: Key = Key(ids=[Qt.Key_Space], name="PLAY / PAUSE")
+    NEXT: Key = Key(ids=[Qt.Key_Right], name="NEXT")
+    PREVIOUS: Key = Key(ids=[Qt.Key_Left], name="PREVIOUS")
+    REVERSE: Key = Key(ids=[Qt.Key_V], name="REVERSE")
+    REPLAY: Key = Key(ids=[Qt.Key_R], name="REPLAY")
+    FULL_SCREEN: Key = Key(ids=[Qt.Key_F], name="TOGGLE FULL SCREEN")
     HIDE_MOUSE: Key = Key(ids=[Qt.Key_H], name="HIDE / SHOW MOUSE")
 
-    @root_validator
+    @model_validator(mode="before")
+    @classmethod
     def ids_are_unique_across_keys(cls, values: Dict[str, Key]) -> Dict[str, Key]:
         ids: Set[int] = set()
 
         for key in values.values():
-            if len(ids.intersection(key.ids)) != 0:
+            if len(ids.intersection(key["ids"])) != 0:
                 raise ValueError(
                     "Two or more keys share a common key code: please make sure each key has distinct key codes"
                 )
-            ids.update(key.ids)
+            ids.update(key["ids"])
 
         return values
 
-    def merge_with(self, other: "Config") -> "Config":
+    def merge_with(self, other: "Keys") -> "Keys":
         for key_name, key in self:
             other_key = getattr(other, key_name)
-            key.ids.update(other_key.ids)
+            key.ids = list(set(key.ids).union(other_key.ids))
             key.name = other_key.name or key.name
 
         return self
 
+    def dispatch_key_function(self) -> Callable[[PositiveInt], None]:
+        _dispatch = {}
 
-class SlideType(str, Enum):
-    slide = "slide"
-    loop = "loop"
-    last = "last"
+        for _, key in self:
+            for _id in key.ids:
+                _dispatch[_id] = key.signal
+
+        def dispatch(key: PositiveInt) -> None:
+            if signal := _dispatch.get(key, None):
+                signal.emit()
+
+        return dispatch
 
 
-class SlideConfig(BaseModel):  # type: ignore
-    type: SlideType
+class Config(BaseModel):  # type: ignore[misc]
+    """General Manim Slides config."""
+
+    keys: Keys = Keys()
+
+    @classmethod
+    def from_file(cls, path: Path) -> "Config":
+        """Read a configuration from a file."""
+        return cls.model_validate(rtoml.load(path))  # type: ignore
+
+    def to_file(self, path: Path) -> None:
+        """Dump the configuration to a file."""
+        rtoml.dump(self.model_dump(), path, pretty=True)
+
+    def merge_with(self, other: "Config") -> "Config":
+        """Merge with another config."""
+        self.keys = self.keys.merge_with(other.keys)
+        return self
+
+
+class PreSlideConfig(BaseModel):  # type: ignore
     start_animation: int
     end_animation: int
-    number: int
-    terminated: bool = False
+    loop: bool = False
+    auto_next: bool = False
 
-    @validator("start_animation", "end_animation")
+    @field_validator("start_animation", "end_animation")
+    @classmethod
     def index_is_posint(cls, v: int) -> int:
         if v < 0:
             raise ValueError("Animation index (start or end) cannot be negative")
         return v
 
-    @validator("number")
-    def number_is_strictly_posint(cls, v: int) -> int:
-        if v <= 0:
-            raise ValueError("Slide number cannot be negative or zero")
-        return v
-
-    @root_validator
+    @model_validator(mode="after")
+    @classmethod
     def start_animation_is_before_end(
-        cls, values: Dict[str, Union[SlideType, int, bool]]
-    ) -> Dict[str, Union[SlideType, int, bool]]:
-        if values["start_animation"] >= values["end_animation"]:  # type: ignore
-            if values["start_animation"] == values["end_animation"] == 0:
+        cls, pre_slide_config: "PreSlideConfig"
+    ) -> "PreSlideConfig":
+        if pre_slide_config.start_animation >= pre_slide_config.end_animation:
+            if pre_slide_config.start_animation == pre_slide_config.end_animation == 0:
                 raise ValueError(
                     "You have to play at least one animation (e.g., `self.wait()`) before pausing. If you want to start paused, use the approriate command-line option when presenting. IMPORTANT: when using ManimGL, `self.wait()` is not considered to be an animation, so prefer to directly use `self.play(...)`."
                 )
@@ -129,114 +163,91 @@ class SlideConfig(BaseModel):  # type: ignore
                 "Start animation index must be strictly lower than end animation index"
             )
 
-        return values
+        return pre_slide_config
 
-    def is_slide(self) -> bool:
-        return self.type == SlideType.slide
+    @model_validator(mode="after")
+    @classmethod
+    def loop_and_auto_next_disallowed(
+        cls, pre_slide_config: "PreSlideConfig"
+    ) -> "PreSlideConfig":
+        if pre_slide_config.loop and pre_slide_config.auto_next:
+            raise ValueError(
+                "You cannot have both `loop=True` and `auto_next=True`, "
+                "because a looping slide has no ending. "
+                "This may be supported in the future if "
+                "https://github.com/jeertmans/manim-slides/pull/299 gets merged."
+            )
 
-    def is_loop(self) -> bool:
-        return self.type == SlideType.loop
-
-    def is_last(self) -> bool:
-        return self.type == SlideType.last
+        return pre_slide_config
 
     @property
     def slides_slice(self) -> slice:
         return slice(self.start_animation, self.end_animation)
 
 
-class PresentationConfig(BaseModel):  # type: ignore
-    slides: List[SlideConfig]
-    files: List[FilePath]
+class SlideConfig(BaseModel):  # type: ignore[misc]
+    file: FilePath
+    rev_file: FilePath
+    loop: bool = False
+    auto_next: bool = False
 
-    @root_validator
-    def animation_indices_match_files(
-        cls, values: Dict[str, Union[List[SlideConfig], List[FilePath]]]
-    ) -> Dict[str, Union[List[SlideConfig], List[FilePath]]]:
-        files = values.get("files")
-        slides = values.get("slides")
+    @classmethod
+    def from_pre_slide_config_and_files(
+        cls, pre_slide_config: PreSlideConfig, file: Path, rev_file: Path
+    ) -> "SlideConfig":
+        return cls(
+            file=file,
+            rev_file=rev_file,
+            loop=pre_slide_config.loop,
+            auto_next=pre_slide_config.auto_next,
+        )
 
-        if files is None or slides is None:
-            return values
 
-        n_files = len(files)
+class PresentationConfig(BaseModel):  # type: ignore[misc]
+    slides: List[SlideConfig] = Field(min_length=1)
+    resolution: Tuple[PositiveInt, PositiveInt] = (1920, 1080)
+    background_color: Color = "black"
 
-        for slide in slides:
-            if slide.end_animation > n_files:  # type: ignore
-                raise ValueError(
-                    f"The following slide's contains animations not listed in files {files}: {slide}"
-                )
+    @classmethod
+    def from_file(cls, path: Path) -> "PresentationConfig":
+        """Read a presentation configuration from a file."""
+        with open(path) as f:
+            obj = json.load(f)
 
-        return values
+            slides = obj.setdefault("slides", [])
+            parent = path.parent.parent  # Never fails, but parents[1] can fail
 
-    def copy_to(self, dest: Path) -> "PresentationConfig":
-        """
-        Copy the files to a given directory.
-        """
-        n = len(self.files)
-        for i in range(n):
-            file = self.files[i]
-            dest_path = dest / self.files[i].name
-            logger.debug(f"Moving / copying {file} to {dest_path}")
-            shutil.copy(file, dest_path)
-            self.files[i] = dest_path
+            for slide in slides:
+                if file := slide.get("file", None):
+                    slide["file"] = parent / file
 
-        return self
+                if rev_file := slide.get("rev_file", None):
+                    slide["rev_file"] = parent / rev_file
 
-    def concat_animations(self, dest: Optional[Path] = None) -> "PresentationConfig":
-        """
-        Concatenate animations such that each slide contains one animation.
-        """
+            return cls.model_validate(obj)  # type: ignore
 
-        dest_paths = []
+    def to_file(self, path: Path) -> None:
+        """Dump the presentation configuration to a file."""
+        with open(path, "w") as f:
+            f.write(self.model_dump_json(indent=2))
 
-        for i, slide_config in enumerate(self.slides):
-            files = self.files[slide_config.slides_slice]
+    def copy_to(self, folder: Path, use_cached: bool = True) -> "PresentationConfig":
+        """Copy the files to a given directory."""
+        for slide_config in self.slides:
+            file = slide_config.file
+            rev_file = slide_config.rev_file
 
-            if len(files) > 1:
-                dest_path = merge_basenames(files)
+            dest = folder / file.name
+            rev_dest = folder / rev_file.name
 
-                f = tempfile.NamedTemporaryFile(mode="w", delete=False)
-                f.writelines(f"file '{os.path.abspath(path)}'\n" for path in files)
-                f.close()
+            slide_config.file = dest
+            slide_config.rev_file = rev_dest
 
-                command: List[str] = [
-                    FFMPEG_BIN,
-                    "-f",
-                    "concat",
-                    "-safe",
-                    "0",
-                    "-i",
-                    f.name,
-                    "-c",
-                    "copy",
-                    str(dest_path),
-                    "-y",
-                ]
-                logger.debug(" ".join(command))
-                process = subprocess.Popen(
-                    command, stdout=subprocess.PIPE, stderr=subprocess.PIPE
-                )
-                output, error = process.communicate()
+            if not use_cached or not dest.exists():
+                shutil.copy(file, dest)
 
-                if output:
-                    logger.debug(output.decode())
-
-                if error:
-                    logger.debug(error.decode())
-
-                dest_paths.append(dest_path)
-
-            else:
-                dest_paths.append(files[0])
-
-            slide_config.start_animation = i
-            slide_config.end_animation = i + 1
-
-        self.files = dest_paths
-
-        if dest:
-            return self.copy_to(dest)
+            if not use_cached or not rev_dest.exists():
+                shutil.copy(rev_file, rev_dest)
 
         return self
 

manim_slides/convert.py

@@ -1,19 +1,55 @@
+import mimetypes
 import os
+import platform
+import subprocess
+import sys
+import tempfile
 import webbrowser
+from base64 import b64encode
 from enum import Enum
+from importlib import resources
 from pathlib import Path
-from typing import Any, Callable, Dict, Generator, List, Optional, Type, Union
+from typing import Any, Callable, Dict, List, Optional, Type, Union
 
 import click
-import pkg_resources
+import cv2
+import pptx
 from click import Context, Parameter
-from pydantic import BaseModel, PositiveInt, ValidationError
+from jinja2 import Template
+from lxml import etree
+from PIL import Image
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    FilePath,
+    GetCoreSchemaHandler,
+    PositiveFloat,
+    PositiveInt,
+    ValidationError,
+    conlist,
+)
+from pydantic_core import CoreSchema, core_schema
+from pydantic_extra_types.color import Color
+from tqdm import tqdm
 
+from . import templates
 from .commons import folder_path_option, verbosity_option
 from .config import PresentationConfig
+from .logger import logger
 from .present import get_scenes_presentation_config
 
 
+def open_with_default(file: Path) -> None:
+    system = platform.system()
+    if system == "Darwin":
+        subprocess.call(("open", str(file)))
+    elif system == "Windows":
+        os.startfile(str(file))  # type: ignore[attr-defined]
+    else:
+        subprocess.call(("xdg-open", str(file)))
+
+
 def validate_config_option(
     ctx: Context, param: Parameter, value: Any
 ) -> Dict[str, str]:
@@ -25,36 +61,59 @@ def validate_config_option(
             config[key] = value
         except ValueError:
             raise click.BadParameter(
-                f"Configuration options `{c_option}` could not be parsed into a proper (key, value) pair. Please use an `=` sign to separate key from value."
-            )
+                f"Configuration options `{c_option}` could not be parsed into "
+                "a proper (key, value) pair. "
+                "Please use an `=` sign to separate key from value."
+            ) from None
 
     return config
 
 
+def file_to_data_uri(file: Path) -> str:
+    """Read a video and return the corresponding data-uri."""
+    b64 = b64encode(file.read_bytes()).decode("ascii")
+    mime_type = mimetypes.guess_type(file)[0] or "video/mp4"
+
+    return f"data:{mime_type};base64,{b64}"
+
+
+def get_duration_ms(file: Path) -> float:
+    """Read a video and return its duration in milliseconds."""
+    cap = cv2.VideoCapture(str(file))
+    fps: int = cap.get(cv2.CAP_PROP_FPS)
+    frame_count: int = cap.get(cv2.CAP_PROP_FRAME_COUNT)
+
+    return 1000 * frame_count / fps
+
+
 class Converter(BaseModel):  # type: ignore
-    presentation_configs: List[PresentationConfig] = []
+    presentation_configs: conlist(PresentationConfig, min_length=1)  # type: ignore[valid-type]
     assets_dir: str = "{basename}_assets"
-    template: Optional[str] = None
+    template: Optional[Path] = None
 
     def convert_to(self, dest: Path) -> None:
-        """Converts self, i.e., a list of presentations, into a given format."""
+        """Convert self, i.e., a list of presentations, into a given format."""
         raise NotImplementedError
 
     def load_template(self) -> str:
-        """Returns the template as a string.
+        """
+        Return the template as a string.
 
-        An empty string is returned if no template is used."""
+        An empty string is returned if no template is used.
+        """
         return ""
 
-    def open(self, file: Path) -> bool:
-        """Opens a file, generated with converter, using appropriate application."""
+    def open(self, file: Path) -> Any:
+        """Open a file, generated with converter, using appropriate application."""
         raise NotImplementedError
 
     @classmethod
     def from_string(cls, s: str) -> Type["Converter"]:
-        """Returns the appropriate converter from a string name."""
+        """Return the appropriate converter from a string name."""
         return {
             "html": RevealJS,
+            "pdf": PDF,
+            "pptx": PowerPoint,
         }[s]
 
 
@@ -64,46 +123,57 @@ class Str(str):
     # This fixes pickling issue on Python 3.8
     __reduce_ex__ = str.__reduce_ex__
 
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, source_type: Any, handler: GetCoreSchemaHandler
+    ) -> CoreSchema:
+        return core_schema.str_schema()
+
     def __str__(self) -> str:
-        """Ensures that the string is correctly quoted."""
+        """Ensure that the string is correctly quoted."""
         if self in ["true", "false", "null"]:
-            return super().__str__()
+            return self
         else:
             return f"'{super().__str__()}'"
 
 
+class StrEnum(Enum):
+    def __str__(self) -> str:
+        return str(self.value)
+
+
 Function = str  # Basically, anything
 
 
-class JsTrue(str, Enum):
+class JsTrue(str, StrEnum):
     true = "true"
 
 
-class JsFalse(str, Enum):
+class JsFalse(str, StrEnum):
     false = "false"
 
 
-class JsBool(Str, Enum):  # type: ignore
+class JsBool(Str, StrEnum):  # type: ignore
     true = "true"
     false = "false"
 
 
-class JsNull(Str, Enum):  # type: ignore
+class JsNull(Str, StrEnum):  # type: ignore
     null = "null"
 
 
-class ControlsLayout(Str, Enum):  # type: ignore
+class ControlsLayout(Str, StrEnum):  # type: ignore
     edges = "edges"
     bottom_right = "bottom-right"
 
 
-class ControlsBackArrows(Str, Enum):  # type: ignore
+class ControlsBackArrows(Str, StrEnum):  # type: ignore
     faded = "faded"
     hidden = "hidden"
     visibly = "visibly"
 
 
-class SlideNumber(Str, Enum):  # type: ignore
+class SlideNumber(Str, StrEnum):  # type: ignore
     true = "true"
     false = "false"
     hdotv = "h.v"
@@ -112,24 +182,24 @@ class SlideNumber(Str, Enum):  # type: ignore
     candt = "c/t"
 
 
-class ShowSlideNumber(Str, Enum):  # type: ignore
+class ShowSlideNumber(Str, StrEnum):  # type: ignore
     all = "all"
     print = "print"
     speaker = "speaker"
 
 
-class KeyboardCondition(Str, Enum):  # type: ignore
+class KeyboardCondition(Str, StrEnum):  # type: ignore
     null = "null"
     focused = "focused"
 
 
-class NavigationMode(Str, Enum):  # type: ignore
+class NavigationMode(Str, StrEnum):  # type: ignore
     default = "default"
     linear = "linear"
     grid = "grid"
 
 
-class AutoPlayMedia(Str, Enum):  # type: ignore
+class AutoPlayMedia(Str, StrEnum):  # type: ignore
     null = "null"
     true = "true"
     false = "false"
@@ -138,25 +208,25 @@ class AutoPlayMedia(Str, Enum):  # type: ignore
 PreloadIframes = AutoPlayMedia
 
 
-class AutoAnimateMatcher(Str, Enum):  # type: ignore
+class AutoAnimateMatcher(Str, StrEnum):  # type: ignore
     null = "null"
 
 
-class AutoAnimateEasing(Str, Enum):  # type: ignore
+class AutoAnimateEasing(Str, StrEnum):  # type: ignore
     ease = "ease"
 
 
 AutoSlide = Union[PositiveInt, JsFalse]
 
 
-class AutoSlideMethod(Str, Enum):  # type: ignore
+class AutoSlideMethod(Str, StrEnum):  # type: ignore
     null = "null"
 
 
 MouseWheel = Union[JsNull, float]
 
 
-class Transition(Str, Enum):  # type: ignore
+class Transition(Str, StrEnum):  # type: ignore
     none = "none"
     fade = "fade"
     slide = "slide"
@@ -165,13 +235,13 @@ class Transition(Str, Enum):  # type: ignore
     zoom = "zoom"
 
 
-class TransitionSpeed(Str, Enum):  # type: ignore
+class TransitionSpeed(Str, StrEnum):  # type: ignore
     default = "default"
     fast = "fast"
     slow = "slow"
 
 
-class BackgroundSize(Str, Enum):  # type: ignore
+class BackgroundSize(Str, StrEnum):  # type: ignore
     # From: https://developer.mozilla.org/en-US/docs/Web/CSS/background-size
     # TODO: support more background size
     contain = "contain"
@@ -181,11 +251,11 @@ class BackgroundSize(Str, Enum):  # type: ignore
 BackgroundTransition = Transition
 
 
-class Display(Str, Enum):  # type: ignore
+class Display(Str, StrEnum):  # type: ignore
     block = "block"
 
 
-class RevealTheme(str, Enum):
+class RevealTheme(str, StrEnum):
     black = "black"
     white = "white"
     league = "league"
@@ -197,9 +267,14 @@ class RevealTheme(str, Enum):
     soralized = "solarized"
     blood = "blood"
     moon = "moon"
+    black_contrast = "black-contrast"
+    white_contrast = "white-contrast"
+    dracula = "dracula"
 
 
 class RevealJS(Converter):
+    # Export option: use data-uri
+    data_uri: bool = False
     # Presentation size options from RevealJS
     width: Union[Str, int] = Str("100%")
     height: Union[Str, int] = Str("100%")
@@ -241,20 +316,22 @@ class RevealJS(Converter):
     auto_animate_easing: AutoAnimateEasing = AutoAnimateEasing.ease
     auto_animate_duration: float = 1.0
     auto_animate_unmatched: JsBool = JsBool.true
-    auto_animate_styles: List[str] = [
-        "opacity",
-        "color",
-        "background-color",
-        "padding",
-        "font-size",
-        "line-height",
-        "letter-spacing",
-        "border-width",
-        "border-color",
-        "border-radius",
-        "outline",
-        "outline-offset",
-    ]
+    auto_animate_styles: List[str] = Field(
+        default_factory=lambda: [
+            "opacity",
+            "color",
+            "background-color",
+            "padding",
+            "font-size",
+            "line-height",
+            "letter-spacing",
+            "border-width",
+            "border-color",
+            "border-radius",
+            "outline",
+            "outline-offset",
+        ]
+    )
     auto_slide: AutoSlide = 0
     auto_slide_stoppable: JsBool = JsBool.true
     auto_slide_method: Union[AutoSlideMethod, Function] = AutoSlideMethod.null
@@ -276,73 +353,212 @@ class RevealJS(Converter):
     display: Display = Display.block
     hide_inactive_cursor: JsBool = JsBool.true
     hide_cursor_time: int = 5000
-    # Add. options
-    background_color: str = "black"  # TODO: use pydantic.color.Color
-    reveal_version: str = "4.4.0"
+    # Appearance options from RevealJS
+    background_color: Color = "black"
+    reveal_version: str = "4.6.1"
     reveal_theme: RevealTheme = RevealTheme.black
     title: str = "Manim Slides"
-
-    class Config:
-        use_enum_values = True
-        extra = "forbid"
-
-    def get_sections_iter(self, assets_dir: Path) -> Generator[str, None, None]:
-        """Generates a sequence of sections, one per slide, that will be included into the html template."""
-        for presentation_config in self.presentation_configs:
-            for slide_config in presentation_config.slides:
-                file = presentation_config.files[slide_config.start_animation]
-                file = assets_dir / file.name
-
-                # TODO: document this
-                # Videos are muted because, otherwise, the first slide never plays correctly.
-                # This is due to a restriction in playing audio without the user doing anything.
-                # Later, this might be useful to only mute the first video, or to make it optional.
-                # Read more about this:
-                #   https://developer.mozilla.org/en-US/docs/Web/Media/Autoplay_guide#autoplay_and_autoplay_blocking
-                if slide_config.is_loop():
-                    yield f'<section data-background-size={self.background_size.value} data-background-video="{file}" data-background-video-muted data-background-video-loop></section>'
-                else:
-                    yield f'<section data-background-size={self.background_size.value} data-background-video="{file}" data-background-video-muted></section>'
+    # Pydantic options
+    model_config = ConfigDict(use_enum_values=True, extra="forbid")
 
     def load_template(self) -> str:
-        """Returns the RevealJS HTML template as a string."""
-        if isinstance(self.template, str):
-            with open(self.template, "r") as f:
-                return f.read()
-        return pkg_resources.resource_string(
-            __name__, "data/revealjs_template.html"
-        ).decode()
+        """Return the RevealJS HTML template as a string."""
+        if isinstance(self.template, Path):
+            return self.template.read_text()
+
+        if sys.version_info < (3, 9):
+            return resources.read_text(templates, "revealjs.html")
+
+        return resources.files(templates).joinpath("revealjs.html").read_text()
 
     def open(self, file: Path) -> bool:
         return webbrowser.open(file.absolute().as_uri())
 
     def convert_to(self, dest: Path) -> None:
-        """Converts this configuration into a RevealJS HTML presentation, saved to DEST."""
-        dirname = dest.parent
-        basename = dest.stem
-        ext = dest.suffix
+        """
+        Convert this configuration into a RevealJS HTML presentation, saved to
+        DEST.
+        """
+        if self.data_uri:
+            assets_dir = Path("")  # Actually we won't care.
+        else:
+            dirname = dest.parent
+            basename = dest.stem
+            ext = dest.suffix
 
-        assets_dir = Path(
-            self.assets_dir.format(dirname=dirname, basename=basename, ext=ext)
-        )
-        full_assets_dir = dirname / assets_dir
+            assets_dir = Path(
+                self.assets_dir.format(dirname=dirname, basename=basename, ext=ext)
+            )
+            full_assets_dir = dirname / assets_dir
 
-        os.makedirs(full_assets_dir, exist_ok=True)
+            logger.debug(f"Assets will be saved to: {full_assets_dir}")
 
-        for presentation_config in self.presentation_configs:
-            presentation_config.concat_animations().copy_to(full_assets_dir)
+            full_assets_dir.mkdir(parents=True, exist_ok=True)
+
+            for presentation_config in self.presentation_configs:
+                presentation_config.copy_to(full_assets_dir)
+
+        dest.parent.mkdir(parents=True, exist_ok=True)
 
         with open(dest, "w") as f:
-            sections = "".join(self.get_sections_iter(assets_dir))
+            revealjs_template = Template(self.load_template())
 
-            revealjs_template = self.load_template()
-            content = revealjs_template.format(sections=sections, **self.dict())
+            options = self.dict()
+            options["assets_dir"] = assets_dir
+
+            content = revealjs_template.render(
+                file_to_data_uri=file_to_data_uri,
+                get_duration_ms=get_duration_ms,
+                **options,
+            )
 
             f.write(content)
 
 
+class FrameIndex(str, Enum):
+    first = "first"
+    last = "last"
+
+
+class PDF(Converter):
+    frame_index: FrameIndex = FrameIndex.last
+    resolution: PositiveFloat = 100.0
+    model_config = ConfigDict(use_enum_values=True, extra="forbid")
+
+    def open(self, file: Path) -> None:
+        return open_with_default(file)
+
+    def convert_to(self, dest: Path) -> None:
+        """Convert this configuration into a PDF presentation, saved to DEST."""
+
+        def read_image_from_video_file(file: Path, frame_index: FrameIndex) -> Image:
+            cap = cv2.VideoCapture(str(file))
+
+            if frame_index == FrameIndex.last:
+                index = cap.get(cv2.CAP_PROP_FRAME_COUNT)
+                cap.set(cv2.CAP_PROP_POS_FRAMES, index - 1)
+
+            ret, frame = cap.read()
+            cap.release()
+
+            if ret:
+                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                return Image.fromarray(frame)
+            else:
+                raise ValueError("Failed to read {image_index} image from video file")
+
+        images = []
+
+        for i, presentation_config in enumerate(self.presentation_configs):
+            for slide_config in tqdm(
+                presentation_config.slides,
+                desc=f"Generating video slides for config {i + 1}",
+                leave=False,
+            ):
+                images.append(
+                    read_image_from_video_file(slide_config.file, self.frame_index)
+                )
+
+        dest.parent.mkdir(parents=True, exist_ok=True)
+
+        images[0].save(
+            dest,
+            "PDF",
+            resolution=self.resolution,
+            save_all=True,
+            append_images=images[1:],
+        )
+
+
+class PowerPoint(Converter):
+    left: PositiveInt = 0
+    top: PositiveInt = 0
+    width: PositiveInt = 1280
+    height: PositiveInt = 720
+    auto_play_media: bool = True
+    poster_frame_image: Optional[FilePath] = None
+    model_config = ConfigDict(use_enum_values=True, extra="forbid")
+
+    def open(self, file: Path) -> None:
+        return open_with_default(file)
+
+    def convert_to(self, dest: Path) -> None:
+        """Convert this configuration into a PowerPoint presentation, saved to DEST."""
+        prs = pptx.Presentation()
+        prs.slide_width = self.width * 9525
+        prs.slide_height = self.height * 9525
+
+        layout = prs.slide_layouts[6]  # Should be blank
+
+        # From GitHub issue comment:
+        # - https://github.com/scanny/python-pptx/issues/427#issuecomment-856724440
+        def auto_play_media(
+            media: pptx.shapes.picture.Movie, loop: bool = False
+        ) -> None:
+            el_id = xpath(media.element, ".//p:cNvPr")[0].attrib["id"]
+            el_cnt = xpath(
+                media.element.getparent().getparent().getparent(),
+                './/p:timing//p:video//p:spTgt[@spid="%s"]' % el_id,
+            )[0]
+            cond = xpath(el_cnt.getparent().getparent(), ".//p:cond")[0]
+            cond.set("delay", "0")
+
+            if loop:
+                ctn = xpath(el_cnt.getparent().getparent(), ".//p:cTn")[0]
+                ctn.set("repeatCount", "indefinite")
+
+        def xpath(el: etree.Element, query: str) -> etree.XPath:
+            nsmap = {"p": "http://schemas.openxmlformats.org/presentationml/2006/main"}
+            return etree.ElementBase.xpath(el, query, namespaces=nsmap)
+
+        def save_first_image_from_video_file(file: Path) -> Optional[str]:
+            cap = cv2.VideoCapture(file.as_posix())
+            ret, frame = cap.read()
+            cap.release()
+
+            if ret:
+                f = tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".png")
+                cv2.imwrite(f.name, frame)
+                f.close()
+                return f.name
+            else:
+                logger.warn("Failed to read first image from video file")
+                return None
+
+        for i, presentation_config in enumerate(self.presentation_configs):
+            for slide_config in tqdm(
+                presentation_config.slides,
+                desc=f"Generating video slides for config {i + 1}",
+                leave=False,
+            ):
+                file = slide_config.file
+
+                mime_type = mimetypes.guess_type(file)[0]
+
+                if self.poster_frame_image is None:
+                    poster_frame_image = save_first_image_from_video_file(file)
+                else:
+                    poster_frame_image = str(self.poster_frame_image)
+
+                slide = prs.slides.add_slide(layout)
+                movie = slide.shapes.add_movie(
+                    str(file),
+                    self.left,
+                    self.top,
+                    self.width * 9525,
+                    self.height * 9525,
+                    poster_frame_image=poster_frame_image,
+                    mime_type=mime_type,
+                )
+                if self.auto_play_media:
+                    auto_play_media(movie, loop=slide_config.loop)
+
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        prs.save(dest)
+
+
 def show_config_options(function: Callable[..., Any]) -> Callable[..., Any]:
-    """Wraps a function to add a `--show-config` option."""
+    """Wrap a function to add a `--show-config` option."""
 
     def callback(ctx: Context, param: Parameter, value: bool) -> None:
         if not value or ctx.resilient_parsing:
@@ -350,13 +566,15 @@ def show_config_options(function: Callable[..., Any]) -> Callable[..., Any]:
 
         to = ctx.params.get("to", "html")
 
-        converter = Converter.from_string(to)(presentation_configs=[])
+        converter = Converter.from_string(to)(
+            presentation_configs=[PresentationConfig()]
+        )
         for key, value in converter.dict().items():
-            click.echo(f"{key}: {repr(value)}")
+            click.echo(f"{key}: {value!r}")
 
         ctx.exit()
 
-    return click.option(
+    return click.option(  # type: ignore
         "--show-config",
         is_flag=True,
         help="Show supported options for given format and exit.",
@@ -368,7 +586,7 @@ def show_config_options(function: Callable[..., Any]) -> Callable[..., Any]:
 
 
 def show_template_option(function: Callable[..., Any]) -> Callable[..., Any]:
-    """Wraps a function to add a `--show-template` option."""
+    """Wrap a function to add a `--show-template` option."""
 
     def callback(ctx: Context, param: Parameter, value: bool) -> None:
         if not value or ctx.resilient_parsing:
@@ -378,13 +596,13 @@ def show_template_option(function: Callable[..., Any]) -> Callable[..., Any]:
         template = ctx.params.get("template", None)
 
         converter = Converter.from_string(to)(
-            presentation_configs=[], template=template
+            presentation_configs=[PresentationConfig()], template=template
         )
         click.echo(converter.load_template())
 
         ctx.exit()
 
-    return click.option(
+    return click.option(  # type: ignore
         "--show-template",
         is_flag=True,
         help="Show the template (currently) used for a given conversion format and exit.",
@@ -401,7 +619,7 @@ def show_template_option(function: Callable[..., Any]) -> Callable[..., Any]:
 @click.argument("dest", type=click.Path(dir_okay=False, path_type=Path))
 @click.option(
     "--to",
-    type=click.Choice(["html"], case_sensitive=False),
+    type=click.Choice(["html", "pdf", "pptx"], case_sensitive=False),
     default="html",
     show_default=True,
     help="Set the conversion format to use.",
@@ -441,10 +659,7 @@ def convert(
     config_options: Dict[str, str],
     template: Optional[Path],
 ) -> None:
-    """
-    Convert SCENE(s) into a given format and writes the result in DEST.
-    """
-
+    """Convert SCENE(s) into a given format and writes the result in DEST."""
     presentation_configs = get_scenes_presentation_config(scenes, folder)
 
     try:
@@ -471,4 +686,4 @@ def convert(
             _msg = error["msg"]
             msg.append(f"Option '{option}': {_msg}")
 
-        raise click.UsageError("\n".join(msg))
+        raise click.UsageError("\n".join(msg)) from None

manim_slides/data/revealjs_template.html

@@ -1,291 +0,0 @@
-<!doctype html>
-<html>
-
-  <head>
-    <meta charset="utf-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
-
-    <title>{title}</title>
-
-    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/reveal.js/{reveal_version}/reveal.min.css">
-    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/reveal.js/{reveal_version}/theme/{reveal_theme}.min.css">
-
-    <!-- Theme used for syntax highlighting of code -->
-    <!-- <link rel="stylesheet" href="lib/css/zenburn.css"> -->
-    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.13.1/styles/zenburn.min.css">
-
-    <!-- <link rel="stylesheet" href="index.css"> -->
-  </head>
-
-  <body>
-    <div class="reveal">
-      <div class="slides">
-        {sections}
-      </div>
-    </div>
-
-    <script src="https://cdnjs.cloudflare.com/ajax/libs/reveal.js/{reveal_version}/reveal.min.js"></script>
-
-    <!-- To include plugins, see: https://revealjs.com/plugins/ -->
-
-    <!-- <script src="index.js"></script> -->
-    <script>
-      Reveal.initialize({{
-
-                // The "normal" size of the presentation, aspect ratio will
-                // be preserved when the presentation is scaled to fit different
-                // resolutions. Can be specified using percentage units.
-                width: {width},
-                height: {height},
-
-                // Factor of the display size that should remain empty around
-                // the content
-                margin: {margin},
-
-                // Bounds for smallest/largest possible scale to apply to content
-                minScale: {min_scale},
-                maxScale: {max_scale},
-
-                // Display presentation control arrows
-                controls: {controls},
-
-                // Help the user learn the controls by providing hints, for example by
-                // bouncing the down arrow when they first encounter a vertical slide
-                controlsTutorial: {controls_tutorial},
-
-                // Determines where controls appear, "edges" or "bottom-right"
-                controlsLayout: {controls_layout},
-
-                // Visibility rule for backwards navigation arrows; "faded", "hidden"
-                // or "visible"
-                controlsBackArrows: {controls_back_arrows},
-
-                // Display a presentation progress bar
-                progress: {progress},
-
-                // Display the page number of the current slide
-                // - true:    Show slide number
-                // - false:   Hide slide number
-                //
-                // Can optionally be set as a string that specifies the number formatting:
-                // - "h.v":   Horizontal . vertical slide number (default)
-                // - "h/v":   Horizontal / vertical slide number
-                // - "c":   Flattened slide number
-                // - "c/t":   Flattened slide number / total slides
-                //
-                // Alternatively, you can provide a function that returns the slide
-                // number for the current slide. The function should take in a slide
-                // object and return an array with one string [slideNumber] or
-                // three strings [n1,delimiter,n2]. See #formatSlideNumber().
-                slideNumber: {slide_number},
-
-                // Can be used to limit the contexts in which the slide number appears
-                // - "all":      Always show the slide number
-                // - "print":    Only when printing to PDF
-                // - "speaker":  Only in the speaker view
-                showSlideNumber: {show_slide_number},
-
-                // Use 1 based indexing for # links to match slide number (default is zero
-                // based)
-                hashOneBasedIndex: {hash_one_based_index},
-
-                // Add the current slide number to the URL hash so that reloading the
-                // page/copying the URL will return you to the same slide
-                hash: {hash},
-
-                // Flags if we should monitor the hash and change slides accordingly
-                respondToHashChanges: {respond_to_hash_changes},
-
-                // Push each slide change to the browser history.  Implies `hash: true`
-                history: {history},
-
-                // Enable keyboard shortcuts for navigation
-                keyboard: {keyboard},
-
-                // Optional function that blocks keyboard events when retuning false
-                //
-                // If you set this to 'focused', we will only capture keyboard events
-                // for embedded decks when they are in focus
-                keyboardCondition: {keyboard_condition},
-
-                // Disables the default reveal.js slide layout (scaling and centering)
-                // so that you can use custom CSS layout
-                disableLayout: {disable_layout},
-
-                // Enable the slide overview mode
-                overview: {overview},
-
-                // Vertical centering of slides
-                center: {center},
-
-                // Enables touch navigation on devices with touch input
-                touch: {touch},
-
-                // Loop the presentation
-                loop: {loop},
-
-                // Change the presentation direction to be RTL
-                rtl: {rtl},
-
-                // Changes the behavior of our navigation directions.
-                //
-                // "default"
-                // Left/right arrow keys step between horizontal slides, up/down
-                // arrow keys step between vertical slides. Space key steps through
-                // all slides (both horizontal and vertical).
-                //
-                // "linear"
-                // Removes the up/down arrows. Left/right arrows step through all
-                // slides (both horizontal and vertical).
-                //
-                // "grid"
-                // When this is enabled, stepping left/right from a vertical stack
-                // to an adjacent vertical stack will land you at the same vertical
-                // index.
-                //
-                // Consider a deck with six slides ordered in two vertical stacks:
-                // 1.1    2.1
-                // 1.2    2.2
-                // 1.3    2.3
-                //
-                // If you're on slide 1.3 and navigate right, you will normally move
-                // from 1.3 -> 2.1. If "grid" is used, the same navigation takes you
-                // from 1.3 -> 2.3.
-                navigationMode: {navigation_mode},
-
-                // Randomizes the order of slides each time the presentation loads
-                shuffle: {shuffle},
-
-                // Turns fragments on and off globally
-                fragments: {fragments},
-
-                // Flags whether to include the current fragment in the URL,
-                // so that reloading brings you to the same fragment position
-                fragmentInURL: {fragment_in_url},
-
-                // Flags if the presentation is running in an embedded mode,
-                // i.e. contained within a limited portion of the screen
-                embedded: {embedded},
-
-                // Flags if we should show a help overlay when the question-mark
-                // key is pressed
-                help: {help},
-
-                // Flags if it should be possible to pause the presentation (blackout)
-                pause: {pause},
-
-                // Flags if speaker notes should be visible to all viewers
-                showNotes: {show_notes},
-
-                // Global override for autolaying embedded media (video/audio/iframe)
-                // - null:   Media will only autoplay if data-autoplay is present
-                // - true:   All media will autoplay, regardless of individual setting
-                // - false:  No media will autoplay, regardless of individual setting
-                autoPlayMedia: {auto_play_media},
-
-                // Global override for preloading lazy-loaded iframes
-                // - null:   Iframes with data-src AND data-preload will be loaded when within
-                //           the viewDistance, iframes with only data-src will be loaded when visible
-                // - true:   All iframes with data-src will be loaded when within the viewDistance
-                // - false:  All iframes with data-src will be loaded only when visible
-                preloadIframes: {preload_iframes},
-
-                // Can be used to globally disable auto-animation
-                autoAnimate: {auto_animate},
-
-                // Optionally provide a custom element matcher that will be
-                // used to dictate which elements we can animate between.
-                autoAnimateMatcher: {auto_animate_matcher},
-
-                // Default settings for our auto-animate transitions, can be
-                // overridden per-slide or per-element via data arguments
-                autoAnimateEasing: {auto_animate_easing},
-                autoAnimateDuration: {auto_animate_duration},
-                autoAnimateUnmatched: {auto_animate_unmatched},
-
-                // CSS properties that can be auto-animated. Position & scale
-                // is matched separately so there's no need to include styles
-                // like top/right/bottom/left, width/height or margin.
-                autoAnimateStyles: {auto_animate_styles},
-
-                // Controls automatic progression to the next slide
-                // - 0:      Auto-sliding only happens if the data-autoslide HTML attribute
-                //           is present on the current slide or fragment
-                // - 1+:     All slides will progress automatically at the given interval
-                // - false:  No auto-sliding, even if data-autoslide is present
-                autoSlide: {auto_slide},
-
-                // Stop auto-sliding after user input
-                autoSlideStoppable: {auto_slide_stoppable},
-
-                // Use this method for navigation when auto-sliding (defaults to navigateNext)
-                autoSlideMethod: {auto_slide_method},
-
-                // Specify the average time in seconds that you think you will spend
-                // presenting each slide. This is used to show a pacing timer in the
-                // speaker view
-                defaultTiming: {default_timing},
-
-                // Enable slide navigation via mouse wheel
-                mouseWheel: {mouse_wheel},
-
-                // Opens links in an iframe preview overlay
-                // Add `data-preview-link` and `data-preview-link="false"` to customise each link
-                // individually
-                previewLinks: {preview_links},
-
-                // Exposes the reveal.js API through window.postMessage
-                postMessage: {post_message},
-
-                // Dispatches all reveal.js events to the parent window through postMessage
-                postMessageEvents: {post_message_events},
-
-                // Focuses body when page changes visibility to ensure keyboard shortcuts work
-                focusBodyOnPageVisibilityChange: {focus_body_on_page_visibility_change},
-
-                // Transition style
-                transition: {transition}, // none/fade/slide/convex/concave/zoom
-
-                // Transition speed
-                transitionSpeed: {transition_speed}, // default/fast/slow
-
-                // Transition style for full page slide backgrounds
-                backgroundTransition: {background_transition}, // none/fade/slide/convex/concave/zoom
-
-                // The maximum number of pages a single slide can expand onto when printing
-                // to PDF, unlimited by default
-                pdfMaxPagesPerSlide: {pdf_max_pages_per_slide},
-
-                // Prints each fragment on a separate slide
-                pdfSeparateFragments: {pdf_separate_fragments},
-
-                // Offset used to reduce the height of content within exported PDF pages.
-                // This exists to account for environment differences based on how you
-                // print to PDF. CLI printing options, like phantomjs and wkpdf, can end
-                // on precisely the total height of the document whereas in-browser
-                // printing has to end one pixel before.
-                pdfPageHeightOffset: {pdf_page_height_offset},
-
-                // Number of slides away from the current that are visible
-                viewDistance: {view_distance},
-
-                // Number of slides away from the current that are visible on mobile
-                // devices. It is advisable to set this to a lower number than
-                // viewDistance in order to save resources.
-                mobileViewDistance: {mobile_view_distance},
-
-                // The display mode that will be used to show slides
-                display: {display},
-
-                // Hide cursor if inactive
-                hideInactiveCursor: {hide_inactive_cursor},
-
-                // Time before the cursor is hidden (in ms)
-                hideCursorTime: {hide_cursor_time}
-
-
-            }});
-    </script>
-  </body>
-
-</html>

manim_slides/defaults.py

@@ -1,2 +1,5 @@
-FOLDER_PATH: str = "./slides"
-CONFIG_PATH: str = ".manim-slides.json"
+from pathlib import Path
+
+FOLDER_PATH: Path = Path("./slides")
+CONFIG_PATH: Path = Path(".manim-slides.toml")
+FFMPEG_BIN: Path = Path("ffmpeg")

manim_slides/docs/manim_slides_directive.py

@@ -0,0 +1,456 @@
+# type: ignore
+r"""
+A directive for including Manim Slides in a Sphinx document
+===========================================================
+
+.. warning::
+
+    This Sphinx extension requires Manim to be installed,
+    and won't probably work on ManimGL examples.
+
+.. note::
+
+    The current implementation is highly inspired from Manim's own
+    sphinx directive, from v0.17.3.
+
+When rendering the HTML documentation, the ``.. manim-slides::``
+directive implemented here allows to include rendered videos.
+
+This directive requires three additional dependencies:
+``manim``, ``docutils`` and ``jinja2``. The last two are usually bundled
+with Sphinx.
+You can install them manually, or with the extra keyword:
+
+    pip install manim-slides[sphinx-directive]
+
+Note that you will still need to install Manim's platform-specific dependencies,
+see
+`their installation page <https://docs.manim.community/en/stable/installation.html>`_.
+
+Usage
+-----
+
+First, you must include the directive in the Sphinx configuration file:
+
+.. code-block:: python
+    :caption: Sphinx configuration file (usually :code:`docs/source/conf.py`).
+    :emphasize-lines: 3
+
+    extensions = [
+        # ...
+        "manim_slides.docs.manim_slides_directive",
+    ]
+
+Its basic usage that allows processing **inline content**
+looks as follows::
+
+    .. manim-slides:: MySlide
+        from manim import *
+        from manim_slides import Slide
+
+        class MySlide(Slide):
+            def construct(self):
+                ...
+
+It is required to pass the name of the class representing the
+scene to be rendered to the directive.
+
+As a second application, the directive can also be used to
+render scenes that are defined within doctests, for example::
+
+    .. manim-slides:: DirectiveDoctestExample
+        :ref_classes: Dot
+
+        >>> from manim import Create, Dot, RED
+        >>> from manim_slides import Slide
+        >>> dot = Dot(color=RED)
+        >>> dot.color
+        <Color #fc6255>
+        >>> class DirectiveDoctestExample(Slide):
+        ...     def construct(self):
+        ...         self.play(Create(dot))
+
+A third application is to render scenes from another specific file::
+
+    .. manim-slides:: file.py:FileExample
+        :hide_source:
+        :quality: high
+
+.. warning::
+
+    The code will be executed with the current working directory
+    being the same as the one containing the source file. This being said,
+    you should probably not include examples that rely on external files, since
+    relative paths risk to be broken.
+
+Options
+-------
+
+Options can be passed as follows::
+
+    .. manim-slides:: <file>:<Class name>
+        :<option name>: <value>
+
+The following configuration options are supported by the
+directive:
+
+    hide_source
+        If this flag is present without argument,
+        the source code is not displayed above the rendered video.
+
+    quality : {'low', 'medium', 'high', 'fourk'}
+        Controls render quality of the video, in analogy to
+        the corresponding command line flags.
+
+    ref_classes
+        A list of classes, separated by spaces, that is
+        rendered in a reference block after the source code.
+
+    ref_functions
+        A list of functions, separated by spaces,
+        that is rendered in a reference block after the source code.
+
+    ref_methods
+        A list of methods, separated by spaces,
+        that is rendered in a reference block after the source code.
+
+"""  # noqa: D400, D415
+from __future__ import annotations
+
+import csv
+import itertools as it
+import re
+import sys
+from pathlib import Path
+from timeit import timeit
+
+import jinja2
+from docutils import nodes
+from docutils.parsers.rst import Directive, directives
+from docutils.statemachine import StringList
+from manim import QUALITIES
+
+from ..convert import RevealJS
+from ..present import get_scenes_presentation_config
+
+classnamedict = {}
+
+
+class SkipManimNode(nodes.Admonition, nodes.Element):
+    """
+    Auxiliary node class that is used when the ``skip-manim-slides`` tag is present or
+    ``.pot`` files are being built.
+
+    Skips rendering the manim-slides directive and outputs a placeholder instead.
+    """
+
+    pass
+
+
+def visit(self, node, name=""):
+    self.visit_admonition(node, name)
+    if not isinstance(node[0], nodes.title):
+        node.insert(0, nodes.title("skip-manim-slides", "Example Placeholder"))
+
+
+def depart(self, node):
+    self.depart_admonition(node)
+
+
+def process_name_list(option_input: str, reference_type: str) -> list[str]:
+    r"""
+    Reformats a string of space separated class names as a list of strings containing
+    valid Sphinx references.
+
+    Tests
+    -----
+
+    ::
+
+        >>> process_name_list("Tex TexTemplate", "class")
+        [':class:`~.Tex`', ':class:`~.TexTemplate`']
+        >>> process_name_list("Scene.play Mobject.rotate", "func")
+        [':func:`~.Scene.play`', ':func:`~.Mobject.rotate`']
+    """
+    return [f":{reference_type}:`~.{name}`" for name in option_input.split()]
+
+
+class ManimSlidesDirective(Directive):
+    r"""
+    The manim-slides directive, rendering videos while building the documentation.
+
+    See the module docstring for documentation.
+    """
+
+    has_content = True
+    required_arguments = 1
+    optional_arguments = 0
+    option_spec = {  # noqa: RUF012
+        "hide_source": bool,
+        "quality": lambda arg: directives.choice(
+            arg,
+            ("low", "medium", "high", "fourk"),
+        ),
+        "ref_modules": lambda arg: process_name_list(arg, "mod"),
+        "ref_classes": lambda arg: process_name_list(arg, "class"),
+        "ref_functions": lambda arg: process_name_list(arg, "func"),
+        "ref_methods": lambda arg: process_name_list(arg, "meth"),
+    }
+    final_argument_whitespace = True
+
+    def run(self):  # noqa: C901
+        # Rendering is skipped if the tag skip-manim is present,
+        # or if we are making the pot-files
+        should_skip = (
+            "skip-manim-slides"
+            in self.state.document.settings.env.app.builder.tags.tags
+            or self.state.document.settings.env.app.builder.name == "gettext"
+        )
+        if should_skip:
+            node = SkipManimNode()
+            self.state.nested_parse(
+                StringList(
+                    [
+                        f"Placeholder block for ``{self.arguments[0]}``.",
+                        "",
+                        ".. code-block:: python",
+                        "",
+                    ]
+                    + ["    " + line for line in self.content]
+                ),
+                self.content_offset,
+                node,
+            )
+            return [node]
+
+        from manim import config, tempconfig
+
+        global classnamedict
+
+        def split_file_cls(arg: str) -> tuple[Path, str]:
+            if ":" in arg:
+                file, cls = arg.split(":", maxsplit=1)
+                _, file = self.state.document.settings.env.relfn2path(file)
+                return Path(file), cls
+            else:
+                return None, arg
+
+        arguments = [split_file_cls(arg) for arg in self.arguments]
+
+        clsname = arguments[0][1]
+        if clsname not in classnamedict:
+            classnamedict[clsname] = 1
+        else:
+            classnamedict[clsname] += 1
+
+        hide_source = "hide_source" in self.options
+
+        ref_content = (
+            self.options.get("ref_modules", [])
+            + self.options.get("ref_classes", [])
+            + self.options.get("ref_functions", [])
+            + self.options.get("ref_methods", [])
+        )
+        if ref_content:
+            ref_block = "References: " + " ".join(ref_content)
+
+        else:
+            ref_block = ""
+
+        if "quality" in self.options:
+            quality = f'{self.options["quality"]}_quality'
+        else:
+            quality = "example_quality"
+        frame_rate = QUALITIES[quality]["frame_rate"]
+        pixel_height = QUALITIES[quality]["pixel_height"]
+        pixel_width = QUALITIES[quality]["pixel_width"]
+
+        state_machine = self.state_machine
+        document = state_machine.document
+
+        source_file_name = Path(document.attributes["source"])
+        source_rel_name = source_file_name.relative_to(setup.confdir)
+        source_rel_dir = source_rel_name.parents[0]
+        dest_dir = Path(setup.app.builder.outdir, source_rel_dir).absolute()
+        if not dest_dir.exists():
+            dest_dir.mkdir(parents=True, exist_ok=True)
+
+        source_block = [
+            ".. code-block:: python",
+            "",
+            *("    " + line for line in self.content),
+        ]
+        source_block = "\n".join(source_block)
+
+        config.media_dir = (Path(setup.confdir) / "media").absolute()
+        config.images_dir = "{media_dir}/images"
+        config.video_dir = "{media_dir}/videos/{quality}"
+        output_file = f"{clsname}-{classnamedict[clsname]}"
+        config.assets_dir = Path("_static")
+        config.progress_bar = "none"
+        config.verbosity = "WARNING"
+
+        example_config = {
+            "frame_rate": frame_rate,
+            "pixel_height": pixel_height,
+            "pixel_width": pixel_width,
+            "output_file": output_file,
+        }
+
+        if file := arguments[0][0]:
+            user_code = file.absolute().read_text().splitlines()
+        else:
+            user_code = self.content
+
+        if user_code[0].startswith(">>> "):  # check whether block comes from doctest
+            user_code = [
+                line[4:] for line in user_code if line.startswith((">>> ", "... "))
+            ]
+
+        code = [
+            *user_code,
+            f"{clsname}().render()",
+        ]
+
+        try:
+            with tempconfig(example_config):
+                print(f"Rendering {clsname}...")  # noqa: T201
+                run_time = timeit(lambda: exec("\n".join(code), globals()), number=1)
+                video_dir = config.get_dir("video_dir")
+        except Exception as e:
+            raise RuntimeError(f"Error while rendering example {clsname}") from e
+
+        _write_rendering_stats(
+            clsname,
+            run_time,
+            self.state.document.settings.env.docname,
+        )
+
+        # copy video file to output directory
+        filename = f"{output_file}.html"
+        filesrc = video_dir / filename
+        destfile = Path(dest_dir, filename)
+        presentation_configs = get_scenes_presentation_config(
+            [clsname], Path("./slides")
+        )
+        RevealJS(presentation_configs=presentation_configs, controls="true").convert_to(
+            destfile
+        )
+
+        rendered_template = jinja2.Template(TEMPLATE).render(
+            clsname=clsname,
+            clsname_lowercase=clsname.lower(),
+            hide_source=hide_source,
+            filesrc_rel=Path(filesrc).relative_to(setup.confdir).as_posix(),
+            output_file=output_file,
+            source_block=source_block,
+            ref_block=ref_block,
+        )
+        state_machine.insert_input(
+            rendered_template.split("\n"),
+            source=document.attributes["source"],
+        )
+
+        return []
+
+
+rendering_times_file_path = Path("../rendering_times.csv")
+
+
+def _write_rendering_stats(scene_name, run_time, file_name):
+    with rendering_times_file_path.open("a") as file:
+        csv.writer(file).writerow(
+            [
+                re.sub(r"^(reference\/)|(manim\.)", "", file_name),
+                scene_name,
+                "%.3f" % run_time,
+            ],
+        )
+
+
+def _log_rendering_times(*args):
+    if rendering_times_file_path.exists():
+        with rendering_times_file_path.open() as file:
+            data = list(csv.reader(file))
+        if len(data) == 0:
+            sys.exit()
+
+        print("\nRendering Summary\n-----------------\n")  # noqa: T201
+
+        max_file_length = max(len(row[0]) for row in data)
+        for key, group in it.groupby(data, key=lambda row: row[0]):
+            key = key.ljust(max_file_length + 1, ".")
+            group = list(group)
+            if len(group) == 1:
+                row = group[0]
+                print(f"{key}{row[2].rjust(7, '.')}s {row[1]}")  # noqa: T201
+                continue
+            time_sum = sum(float(row[2]) for row in group)
+            print(  # noqa: T201
+                f"{key}{f'{time_sum:.3f}'.rjust(7, '.')}s  => {len(group)} EXAMPLES",
+            )
+            for row in group:
+                print(  # noqa: T201
+                    f"{' '*(max_file_length)} {row[2].rjust(7)}s {row[1]}"
+                )
+        print("")  # noqa: T201
+
+
+def _delete_rendering_times(*args):
+    if rendering_times_file_path.exists():
+        rendering_times_file_path.unlink()
+
+
+def setup(app):
+    app.add_node(SkipManimNode, html=(visit, depart))
+
+    setup.app = app
+    setup.config = app.config
+    setup.confdir = app.confdir
+
+    app.add_directive("manim-slides", ManimSlidesDirective)
+
+    app.connect("builder-inited", _delete_rendering_times)
+    app.connect("build-finished", _log_rendering_times)
+
+    metadata = {"parallel_read_safe": False, "parallel_write_safe": True}
+    return metadata
+
+
+TEMPLATE = r"""
+{% if not hide_source %}
+.. raw:: html
+
+    <div id="{{ clsname_lowercase }}" class="admonition admonition-manim-example">
+    <p class="admonition-title">Example: {{ clsname }} <a class="headerlink" href="#{{ clsname_lowercase }}">¶</a></p>
+
+{% endif %}
+
+
+.. raw:: html
+
+    <!-- From: https://faq.dailymotion.com/hc/en-us/articles/360022841393-How-to-preserve-the-player-aspect-ratio-on-a-responsive-page -->
+
+    <div style="position:relative;padding-bottom:56.25%;">
+        <iframe
+            style="width:100%;height:100%;position:absolute;left:0px;top:0px;"
+            frameborder="0"
+            width="100%"
+            height="100%"
+            allowfullscreen
+            allow="autoplay"
+            src="./{{ output_file }}.html">
+        </iframe>
+    </div>
+
+{% if not hide_source %}
+{{ source_block }}
+
+{{ ref_block }}
+
+.. raw:: html
+
+    </div>
+
+{% endif %}
+"""

manim_slides/ipython/ipython_magic.py

@@ -0,0 +1,265 @@
+"""
+Utilities for using Manim Slides with IPython (in particular: Jupyter notebooks).
+=================================================================================
+
+.. toctree::
+    :hidden:
+
+    magic_example
+
+
+.. note::
+
+    The current implementation is highly inspired from Manim's own
+    IPython magics, from v0.17.3.
+
+This magic requires two additional dependencies: ``manim`` and ``IPython``.
+You can install them manually, or with the extra keyword:
+
+    pip install manim-slides[magic]
+
+Note that you will still need to install Manim's platform-specific dependencies,
+see
+`their installation page <https://docs.manim.community/en/stable/installation.html>`_.
+"""  # noqa: D400, D415
+
+from __future__ import annotations
+
+import logging
+import mimetypes
+import shutil
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from IPython import get_ipython
+from IPython.core.interactiveshell import InteractiveShell
+from IPython.core.magic import Magics, line_cell_magic, magics_class, needs_local_scope
+from IPython.display import HTML, display
+from manim import config, logger, tempconfig
+from manim.__main__ import main
+from manim.constants import RendererType
+from manim.renderer.shader import shader_program_cache
+
+from ..convert import RevealJS
+from ..present import get_scenes_presentation_config
+
+
+@magics_class
+class ManimSlidesMagic(Magics):  # type: ignore
+    def __init__(self, shell: InteractiveShell) -> None:
+        super().__init__(shell)
+        self.rendered_files: dict[Path, Path] = {}
+
+    @needs_local_scope
+    @line_cell_magic
+    def manim_slides(  # noqa: C901
+        self,
+        line: str,
+        cell: str | None = None,
+        local_ns: dict[str, Any] | None = None,
+    ) -> None:
+        r"""
+        Render Manim Slides contained in IPython cells. Works as a line or cell magic.
+
+        .. note::
+
+            This magic works pretty much like the one from Manim, except that it
+            will render Manim Slides using RevealJS. For passing arguments to
+            Manim Slides' convert module, use ``-manim-slides key=value``.
+
+            Everything that is after ``--manim-slides`` will be send to
+            Manim Slides' command. E.g., use ``--manim-slides controls=true``
+            to display control buttons.
+
+        .. hint::
+
+            This line and cell magic works best when used in a JupyterLab
+            environment: while all of the functionality is available for
+            classic Jupyter notebooks as well, it is possible that videos
+            sometimes don't update on repeated execution of the same cell
+            if the scene name stays the same.
+
+            This problem does not occur when using JupyterLab.
+
+        Please refer to `<https://jupyter.org/>`_ for more information about JupyterLab
+        and Jupyter notebooks.
+
+        Usage in line mode::
+
+            %manim_slides [CLI options] MyAwesomeSlide
+
+        Usage in cell mode::
+
+            %%manim_slides [CLI options] MyAwesomeSlide
+
+            class MyAweseomeSlide(Slide):
+                def construct(self):
+                    ...
+
+        Run ``%manim_slides --help`` and ``%manim_slides render --help``
+        for possible command line interface options.
+
+        .. note::
+
+            The maximal width of the rendered videos that are displayed in the notebook can be
+            configured via the ``media_width`` configuration option. The default is set to ``25vw``,
+            which is 25% of your current viewport width. To allow the output to become as large
+            as possible, set ``config.media_width = "100%"``.
+
+            The ``media_embed`` option will embed the image/video output in the notebook. This is
+            generally undesirable as it makes the notebooks very large, but is required on some
+            platforms (notably Google's CoLab, where it is automatically enabled unless suppressed
+            by ``config.embed = False``) and needed in cases when the notebook (or converted HTML
+            file) will be moved relative to the video locations. Use-cases include building
+            documentation with Sphinx and JupyterBook. See also the
+            :mod:`Manim Slides directive for Sphinx
+            <manim_slides.docs.manim_slides_directive>`.
+
+        Examples
+        --------
+        First make sure to put ``from manim_slides import ManimSlidesMagic``,
+        or even ``from manim_slides import *``
+        in a cell and evaluate it. Then, a typical Jupyter notebook cell for Manim Slides
+        could look as follows::
+
+            %%manim_slides -v WARNING --progress_bar None MySlide --manim-slides controls=true data_uri=true
+
+            class MySlide(Slide):
+                def construct(self):
+                    square = Square()
+                    circle = Circle()
+
+                    self.play(Create(square))
+                    self.next_slide()
+                    self.play(Transform(square, circle))
+
+        Evaluating this cell will render and display the ``MySlide`` slide
+        defined in the body of the cell.
+
+        .. note::
+
+            In case you want to hide the red box containing the output progress bar, the ``progress_bar`` config
+            option should be set to ``None``. This can also be done by passing ``--progress_bar None`` as a
+            CLI flag.
+        """
+        if local_ns is None:
+            local_ns = {}
+        if cell:
+            exec(cell, local_ns)
+
+        split_args = line.split("--manim-slides", 2)
+        manim_args = split_args[0].split()
+
+        if len(split_args) == 2:
+            manim_slides_args = split_args[1].split()
+        else:
+            manim_slides_args = []
+
+        args = manim_args
+        if not len(args) or "-h" in args or "--help" in args or "--version" in args:
+            main(args, standalone_mode=False, prog_name="manim")
+            return
+
+        modified_args = self.add_additional_args(args)
+        args = main(modified_args, standalone_mode=False, prog_name="manim")
+        with tempconfig(local_ns.get("config", {})):
+            config.digest_args(args)
+            logging.getLogger("manim-slides").setLevel(logging.getLogger("manim").level)
+
+            renderer = None
+            if config.renderer == RendererType.OPENGL:
+                from manim.renderer.opengl_renderer import OpenGLRenderer
+
+                renderer = OpenGLRenderer()
+
+            try:
+                scene_cls = local_ns[config["scene_names"][0]]
+                scene = scene_cls(renderer=renderer)
+                scene.render()
+            finally:
+                # Shader cache becomes invalid as the context is destroyed
+                shader_program_cache.clear()
+
+                # Close OpenGL window here instead of waiting for the main thread to
+                # finish causing the window to stay open and freeze
+                if renderer is not None and renderer.window is not None:
+                    renderer.window.close()
+
+            if config["output_file"] is None:
+                logger.info("No output file produced")
+                return
+
+            local_path = Path(config["output_file"]).relative_to(Path.cwd())
+            tmpfile = (
+                Path(config["media_dir"]) / "jupyter" / f"{_generate_file_name()}.html"
+            )
+
+            if local_path in self.rendered_files:
+                self.rendered_files[local_path].unlink()
+                pass
+            self.rendered_files[local_path] = tmpfile
+            tmpfile.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy(local_path, tmpfile)
+
+            file_type = mimetypes.guess_type(config["output_file"])[0] or "video/mp4"
+            embed = config["media_embed"]
+            if embed is None:
+                # videos need to be embedded when running in google colab.
+                # do this automatically in case config.media_embed has not been
+                # set explicitly.
+                embed = "google.colab" in str(get_ipython())
+
+            if not file_type.startswith("video"):
+                raise ValueError(
+                    f"Manim Slides only supports video files, not {file_type}"
+                )
+
+            clsname = config["scene_names"][0]
+
+            kwargs = dict(arg.split("=", 1) for arg in manim_slides_args)
+
+            if embed:  # Embedding implies data-uri
+                kwargs["data_uri"] = "true"
+
+            # TODO: FIXME
+            # Seems like files are blocked so date-uri is the only working option...
+            if kwargs.get("data_uri", "false").lower().strip() == "false":
+                logger.warn(
+                    "data_uri option is currently automatically enabled, "
+                    "because using local video files does not seem to work properly."
+                )
+                kwargs["data_uri"] = "true"
+
+            presentation_configs = get_scenes_presentation_config(
+                [clsname], Path("./slides")
+            )
+            RevealJS(presentation_configs=presentation_configs, **kwargs).convert_to(
+                tmpfile
+            )
+
+            if embed:
+                result = HTML(
+                    """<div style="position:relative;padding-bottom:56.25%;"><iframe style="width:100%;height:100%;position:absolute;left:0px;top:0px;" frameborder="0" width="100%" height="100%" allowfullscreen allow="autoplay" srcdoc="{srcdoc}"></iframe></div>""".format(
+                        srcdoc=tmpfile.read_text().replace('"', "'")
+                    )
+                )
+            else:
+                result = HTML(
+                    """<div style="position:relative;padding-bottom:56.25%;"><iframe style="width:100%;height:100%;position:absolute;left:0px;top:0px;" frameborder="0" width="100%" height="100%" allowfullscreen allow="autoplay" src="{src}"></iframe></div>""".format(
+                        src=tmpfile.as_posix()
+                    )
+                )
+
+            display(result)
+
+    def add_additional_args(self, args: list[str]) -> list[str]:
+        additional_args = ["--jupyter"]
+        # Use webm to support transparency
+        if "-t" in args and "--format" not in args:
+            additional_args += ["--format", "webm"]
+        return additional_args + args[:-1] + [""] + [args[-1]]
+
+
+def _generate_file_name() -> str:
+    return config["scene_names"][0] + "@" + datetime.now().strftime("%Y-%m-%d@%H-%M-%S")  # type: ignore

manim_slides/logger.py

@@ -0,0 +1,49 @@
+"""
+Logger utils, mostly copied from Manim Community.
+
+Source code:
+https://github.com/ManimCommunity/manim/blob/d5b65b844b8ce8ff5151a2f56f9dc98cebbc1db4/manim/_config/logger_utils.py#L29-L101
+"""
+
+import logging
+
+from rich.console import Console
+from rich.logging import RichHandler
+
+__all__ = ["logger"]
+
+HIGHLIGHTED_KEYWORDS = [  # these keywords are highlighted specially
+    "Played",
+    "animations",
+    "scene",
+    "Reading",
+    "Writing",
+    "script",
+    "arguments",
+    "Invalid",
+    "Aborting",
+    "module",
+    "File",
+    "Rendering",
+    "Rendered",
+    "Pressed key",
+]
+
+
+def make_logger() -> logging.Logger:
+    """Make a logger similar to the one used by Manim."""
+    RichHandler.KEYWORDS = HIGHLIGHTED_KEYWORDS
+    rich_handler = RichHandler(
+        show_time=True,
+        console=Console(),
+    )
+    logger = logging.getLogger("manim-slides")
+    logger.setLevel(logging.getLogger("manim").level)
+    logger.addHandler(rich_handler)
+
+    return logger
+
+
+make_logger()
+
+logger = logging.getLogger("manim-slides")

manim_slides/manim.py

@@ -1,81 +0,0 @@
-import os
-import sys
-from contextlib import contextmanager
-from importlib.util import find_spec
-from typing import Iterator
-
-__all__ = [
-    "MANIM",
-    "MANIM_PACKAGE_NAME",
-    "MANIM_AVAILABLE",
-    "MANIM_IMPORTED",
-    "MANIMGL",
-    "MANIMGL_PACKAGE_NAME",
-    "MANIMGL_AVAILABLE",
-    "MANIMGL_IMPORTED",
-    "logger",
-    "Scene",
-    "ThreeDScene",
-    "config",
-    "FFMPEG_BIN",
-]
-
-
-@contextmanager
-def suppress_stdout() -> Iterator[None]:
-    with open(os.devnull, "w") as devnull:
-        old_stdout = sys.stdout
-        sys.stdout = devnull
-        try:
-            yield
-        finally:
-            sys.stdout = old_stdout
-
-
-MANIM_PACKAGE_NAME = "manim"
-MANIM_AVAILABLE = find_spec(MANIM_PACKAGE_NAME) is not None
-MANIM_IMPORTED = MANIM_PACKAGE_NAME in sys.modules
-
-MANIMGL_PACKAGE_NAME = "manimlib"
-MANIMGL_AVAILABLE = find_spec(MANIMGL_PACKAGE_NAME) is not None
-MANIMGL_IMPORTED = MANIMGL_PACKAGE_NAME in sys.modules
-
-if MANIM_IMPORTED and MANIMGL_IMPORTED:
-    from manim import logger
-
-    logger.warn(
-        "Both manim and manimgl are installed, therefore `manim-slide` needs to need which one to use. Please only import one of the two modules so that `manim-slide` knows which one to use. Here, manim is used by default"
-    )
-    MANIM = True
-    MANIMGL = False
-elif MANIM_IMPORTED:
-    MANIM = True
-    MANIMGL = False
-elif MANIMGL_IMPORTED:
-    MANIM = False
-    MANIMGL = True
-elif MANIM_AVAILABLE:
-    MANIM = True
-    MANIMGL = False
-elif MANIMGL_AVAILABLE:
-    MANIM = False
-    MANIMGL = True
-else:
-    raise ModuleNotFoundError(
-        "Either manim (community) or manimgl (3b1b) package must be installed"
-    )
-
-
-if MANIMGL:
-    from manimlib import Scene, ThreeDScene, config
-    from manimlib.constants import FFMPEG_BIN
-    from manimlib.logger import log as logger
-
-else:
-    with suppress_stdout():  # Avoids printing "Manim Community v..."
-        from manim import Scene, ThreeDScene, config, logger
-
-        try:  # For manim<v0.16.0.post0
-            from manim.constants import FFMPEG_BIN
-        except ImportError:
-            FFMPEG_BIN = config.ffmpeg_executable

manim_slides/present.py

@@ -1,860 +0,0 @@
-import os
-import platform
-import sys
-import time
-from enum import Enum, IntEnum, auto, unique
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Union
-
-import click
-import cv2
-import numpy as np
-from pydantic import ValidationError
-from PySide6.QtCore import Qt, QThread, Signal, Slot
-from PySide6.QtGui import QCloseEvent, QIcon, QImage, QKeyEvent, QPixmap, QResizeEvent
-from PySide6.QtWidgets import QApplication, QGridLayout, QLabel, QWidget
-from tqdm import tqdm
-
-from .commons import config_path_option, verbosity_option
-from .config import DEFAULT_CONFIG, Config, PresentationConfig, SlideConfig
-from .defaults import FOLDER_PATH
-from .manim import logger
-from .resources import *  # noqa: F401, F403
-
-os.environ.pop(
-    "QT_QPA_PLATFORM_PLUGIN_PATH", None
-)  # See why here: https://stackoverflow.com/a/67863156
-
-WINDOW_NAME = "Manim Slides"
-WINDOW_INFO_NAME = f"{WINDOW_NAME}: Info"
-WINDOWS = platform.system() == "Windows"
-
-
-class AspectRatio(Enum):
-    ignore = Qt.IgnoreAspectRatio
-    keep = Qt.KeepAspectRatio
-    auto = "auto"
-
-
-ASPECT_RATIO_MODES = {
-    "ignore": AspectRatio.ignore,
-    "keep": AspectRatio.keep,
-    "auto": AspectRatio.auto,
-}
-
-RESIZE_MODES = {
-    "fast": Qt.FastTransformation,
-    "smooth": Qt.SmoothTransformation,
-}
-
-
-@unique
-class State(IntEnum):
-    """Represents all possible states of a slide presentation."""
-
-    PLAYING = auto()
-    PAUSED = auto()
-    WAIT = auto()
-    END = auto()
-
-    def __str__(self) -> str:
-        return self.name.capitalize()
-
-
-def now() -> float:
-    """Returns time.time() in seconds."""
-    return time.time()
-
-
-class Presentation:
-    """Creates presentation from a configuration object."""
-
-    def __init__(self, config: PresentationConfig) -> None:
-        self.slides: List[SlideConfig] = config.slides
-        self.files: List[str] = config.files
-
-        self.current_slide_index: int = 0
-        self.current_animation: int = self.current_slide.start_animation
-        self.current_file: str = ""
-
-        self.loaded_animation_cap: int = -1
-        self.cap = None  # cap = cv2.VideoCapture
-
-        self.reverse: bool = False
-        self.reversed_animation: int = -1
-
-        self.lastframe: Optional[np.ndarray] = None
-
-        self.reset()
-
-    @property
-    def current_slide(self) -> SlideConfig:
-        """Returns currently playing slide."""
-        return self.slides[self.current_slide_index]
-
-    @property
-    def first_slide(self) -> SlideConfig:
-        """Returns first slide."""
-        return self.slides[0]
-
-    @property
-    def last_slide(self) -> SlideConfig:
-        """Returns last slide."""
-        return self.slides[-1]
-
-    def release_cap(self) -> None:
-        """Releases current Video Capture, if existing."""
-        if self.cap is not None:
-            self.cap.release()
-
-        self.loaded_animation_cap = -1
-
-    def load_animation_cap(self, animation: int) -> None:
-        """Loads video file of given animation."""
-        # We must load a new VideoCapture file if:
-        if (self.loaded_animation_cap != animation) or (
-            self.reverse and self.reversed_animation != animation
-        ):  # cap already loaded
-            logger.debug(f"Loading new cap for animation #{animation}")
-
-            self.release_cap()
-
-            file: str = self.files[animation]
-
-            if self.reverse:
-                file = "{}_reversed{}".format(*os.path.splitext(file))
-                self.reversed_animation = animation
-
-            self.current_file = file
-
-            self.cap = cv2.VideoCapture(str(file))
-            self.loaded_animation_cap = animation
-
-    @property
-    def current_cap(self) -> cv2.VideoCapture:
-        """Returns current VideoCapture object."""
-        self.load_animation_cap(self.current_animation)
-        return self.cap
-
-    def rewind_current_slide(self) -> None:
-        """Rewinds current slide to first frame."""
-        logger.debug("Rewinding curring slide")
-        if self.reverse:
-            self.current_animation = self.current_slide.end_animation - 1
-        else:
-            self.current_animation = self.current_slide.start_animation
-
-        cap = self.current_cap
-        cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
-
-    def cancel_reverse(self) -> None:
-        """Cancels any effet produced by a reversed slide."""
-        if self.reverse:
-            logger.debug("Cancelling effects from previous 'reverse' action'")
-            self.reverse = False
-            self.reversed_animation = -1
-            self.release_cap()
-
-    def reverse_current_slide(self) -> None:
-        """Reverses current slide."""
-        self.reverse = True
-        self.rewind_current_slide()
-
-    def load_next_slide(self) -> None:
-        """Loads next slide."""
-        logger.debug("Loading next slide")
-        if self.reverse:
-            self.cancel_reverse()
-            self.rewind_current_slide()
-        elif self.current_slide.is_last():
-            self.current_slide.terminated = True
-        else:
-            self.current_slide_index = min(
-                len(self.slides) - 1, self.current_slide_index + 1
-            )
-            self.rewind_current_slide()
-
-    def load_previous_slide(self) -> None:
-        """Loads previous slide."""
-        logger.debug("Loading previous slide")
-        self.cancel_reverse()
-        self.current_slide_index = max(0, self.current_slide_index - 1)
-        self.rewind_current_slide()
-
-    @property
-    def fps(self) -> int:
-        """Returns the number of frames per second of the current video."""
-        fps = self.current_cap.get(cv2.CAP_PROP_FPS)
-        if fps == 0:
-            logger.warn(
-                f"Something is wrong with video file {self.current_file}, as the fps returned by frame {self.current_frame_number} is 0"
-            )
-        return max(fps, 1)  # TODO: understand why we sometimes get 0 fps
-
-    def reset(self) -> None:
-        """Rests current presentation."""
-        self.current_animation = 0
-        self.load_animation_cap(0)
-        self.current_slide_index = 0
-        self.slides[-1].terminated = False
-
-    def load_last_slide(self) -> None:
-        """Loads last slide."""
-        self.current_slide_index = len(self.slides) - 2
-        assert (
-            self.current_slide_index >= 0
-        ), "Slides should be at list of a least two elements"
-        self.current_animation = self.current_slide.start_animation
-        self.load_animation_cap(self.current_animation)
-        self.slides[-1].terminated = False
-
-    @property
-    def next_animation(self) -> int:
-        """Returns the next animation."""
-        if self.reverse:
-            return self.current_animation - 1
-        else:
-            return self.current_animation + 1
-
-    @property
-    def is_last_animation(self) -> int:
-        """Returns True if current animation is the last one of current slide."""
-        if self.reverse:
-            return self.current_animation == self.current_slide.start_animation
-        else:
-            return self.next_animation == self.current_slide.end_animation
-
-    @property
-    def current_frame_number(self) -> int:
-        """Returns current frame number."""
-        return int(self.current_cap.get(cv2.CAP_PROP_POS_FRAMES))
-
-    def update_state(self, state: State) -> Tuple[np.ndarray, State]:
-        """
-        Updates the current state given the previous one.
-
-        It does this by reading the video information and checking if the state is still correct.
-        It returns the frame to show (lastframe) and the new state.
-        """
-        if state == State.PAUSED:
-            if self.lastframe is None:
-                _, self.lastframe = self.current_cap.read()
-            return self.lastframe, state
-        still_playing, frame = self.current_cap.read()
-        if still_playing:
-            self.lastframe = frame
-        elif state == state.WAIT or state == state.PAUSED:  # type: ignore
-            return self.lastframe, state
-        elif self.current_slide.is_last() and self.current_slide.terminated:
-            return self.lastframe, State.END
-        else:  # not still playing
-            if self.is_last_animation:
-                if self.current_slide.is_slide():
-                    state = State.WAIT
-                elif self.current_slide.is_loop():
-                    if self.reverse:
-                        state = State.WAIT
-                    else:
-                        self.current_animation = self.current_slide.start_animation
-                        state = State.PLAYING
-                        self.rewind_current_slide()
-                elif self.current_slide.is_last():
-                    self.current_slide.terminated = True
-            elif (
-                self.current_slide.is_last()
-                and self.current_slide.end_animation == self.current_animation
-            ):
-                state = State.WAIT
-            else:
-                # Play next video!
-                self.current_animation = self.next_animation
-                self.load_animation_cap(self.current_animation)
-                # Reset video to position zero if it has been played before
-                self.current_cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
-
-        return self.lastframe, state
-
-
-class Display(QThread):  # type: ignore
-    """Displays one or more presentations one after each other."""
-
-    change_video_signal = Signal(np.ndarray)
-    change_info_signal = Signal(dict)
-    finished = Signal()
-
-    def __init__(
-        self,
-        presentations: List[PresentationConfig],
-        config: Config = DEFAULT_CONFIG,
-        start_paused: bool = False,
-        skip_all: bool = False,
-        record_to: Optional[str] = None,
-        exit_after_last_slide: bool = False,
-    ) -> None:
-        super().__init__()
-        self.presentations = presentations
-        self.start_paused = start_paused
-        self.config = config
-        self.skip_all = skip_all
-        self.record_to = record_to
-        self.recordings: List[Tuple[str, int, int]] = []
-
-        self.state = State.PLAYING
-        self.lastframe: Optional[np.ndarray] = None
-        self.current_presentation_index = 0
-        self.run_flag = True
-
-        self.key = -1
-        self.exit_after_last_slide = exit_after_last_slide
-
-    @property
-    def current_presentation(self) -> Presentation:
-        """Returns the current presentation."""
-        return self.presentations[self.current_presentation_index]
-
-    def run(self) -> None:
-        """Runs a series of presentations until end or exit."""
-        while self.run_flag:
-            last_time = now()
-            self.lastframe, self.state = self.current_presentation.update_state(
-                self.state
-            )
-            if self.state == State.PLAYING or self.state == State.PAUSED:
-                if self.start_paused:
-                    self.state = State.PAUSED
-                    self.start_paused = False
-            if self.state == State.END:
-                if self.current_presentation_index == len(self.presentations) - 1:
-                    if self.exit_after_last_slide:
-                        self.run_flag = False
-                        continue
-                else:
-                    self.current_presentation_index += 1
-                    self.state = State.PLAYING
-
-            self.handle_key()
-            self.show_video()
-            self.show_info()
-
-            lag = now() - last_time
-            sleep_time = 1 / self.current_presentation.fps
-            sleep_time = max(sleep_time - lag, 0)
-            time.sleep(sleep_time)
-            last_time = now()
-        self.current_presentation.release_cap()
-
-        if self.record_to is not None:
-            self.record_movie()
-
-        logger.debug("Closing video thread gracully and exiting")
-        self.finished.emit()
-
-    def record_movie(self) -> None:
-        logger.debug(
-            f"A total of {len(self.recordings)} frames will be saved to {self.record_to}"
-        )
-        file, frame_number, fps = self.recordings[0]
-
-        cap = cv2.VideoCapture(file)
-        cap.set(cv2.CAP_PROP_POS_FRAMES, frame_number - 1)
-        _, frame = cap.read()
-
-        w, h = frame.shape[:2]
-        fourcc = cv2.VideoWriter_fourcc(*"XVID")
-        out = cv2.VideoWriter(self.record_to, fourcc, fps, (h, w))
-
-        out.write(frame)
-
-        for _file, frame_number, _ in tqdm(
-            self.recordings[1:], desc="Creating recording file", leave=False
-        ):
-            if file != _file:
-                cap.release()
-                file = _file
-                cap = cv2.VideoCapture(_file)
-
-            cap.set(cv2.CAP_PROP_POS_FRAMES, frame_number - 1)
-            _, frame = cap.read()
-            out.write(frame)
-
-        cap.release()
-        out.release()
-
-    def show_video(self) -> None:
-        """Shows updated video."""
-        if self.record_to is not None:
-            pres = self.current_presentation
-            self.recordings.append(
-                (pres.current_file, pres.current_frame_number, pres.fps)
-            )
-
-        frame: np.ndarray = self.lastframe
-        self.change_video_signal.emit(frame)
-
-    def show_info(self) -> None:
-        """Shows updated information about presentations."""
-        self.change_info_signal.emit(
-            {
-                "animation": self.current_presentation.current_animation,
-                "state": self.state,
-                "slide_index": self.current_presentation.current_slide.number,
-                "n_slides": len(self.current_presentation.slides),
-                "type": self.current_presentation.current_slide.type,
-                "scene_index": self.current_presentation_index + 1,
-                "n_scenes": len(self.presentations),
-            }
-        )
-
-    @Slot(int)
-    def set_key(self, key: int) -> None:
-        """Sets the next key to be handled."""
-        self.key = key
-
-    def handle_key(self) -> None:
-        """Handles key strokes."""
-
-        key = self.key
-
-        if self.config.QUIT.match(key):
-            self.run_flag = False
-        elif self.state == State.PLAYING and self.config.PLAY_PAUSE.match(key):
-            self.state = State.PAUSED
-        elif self.state == State.PAUSED and self.config.PLAY_PAUSE.match(key):
-            self.state = State.PLAYING
-        elif self.state == State.WAIT and (
-            self.config.CONTINUE.match(key) or self.config.PLAY_PAUSE.match(key)
-        ):
-            self.current_presentation.load_next_slide()
-            self.state = State.PLAYING
-        elif (
-            self.state == State.PLAYING and self.config.CONTINUE.match(key)
-        ) or self.skip_all:
-            self.current_presentation.load_next_slide()
-        elif self.config.BACK.match(key):
-            if self.current_presentation.current_slide_index == 0:
-                if self.current_presentation_index == 0:
-                    self.current_presentation.load_previous_slide()
-                else:
-                    self.current_presentation_index -= 1
-                    self.current_presentation.load_last_slide()
-                self.state = State.PLAYING
-            else:
-                self.current_presentation.load_previous_slide()
-                self.state = State.PLAYING
-        elif self.config.REVERSE.match(key):
-            self.current_presentation.reverse_current_slide()
-            self.state = State.PLAYING
-        elif self.config.REWIND.match(key):
-            self.current_presentation.cancel_reverse()
-            self.current_presentation.rewind_current_slide()
-            self.state = State.PLAYING
-
-        self.key = -1  # No more key to be handled
-
-    def stop(self) -> None:
-        """Stops current thread, without doing anything after."""
-        self.run_flag = False
-        self.wait()
-
-
-class Info(QWidget):  # type: ignore
-    def __init__(self) -> None:
-        super().__init__()
-        self.setWindowTitle(WINDOW_INFO_NAME)
-
-        self.layout = QGridLayout()
-
-        self.setLayout(self.layout)
-
-        self.animationLabel = QLabel()
-        self.stateLabel = QLabel()
-        self.slideLabel = QLabel()
-        self.typeLabel = QLabel()
-        self.sceneLabel = QLabel()
-
-        self.layout.addWidget(self.animationLabel, 0, 0, 1, 2)
-        self.layout.addWidget(self.stateLabel, 1, 0)
-        self.layout.addWidget(self.slideLabel, 1, 1)
-        self.layout.addWidget(self.typeLabel, 2, 0)
-        self.layout.addWidget(self.sceneLabel, 2, 1)
-
-        self.update_info({})
-
-    @Slot(dict)
-    def update_info(self, info: Dict[str, Union[str, int]]) -> None:
-        self.animationLabel.setText("Animation: {}".format(info.get("animation", "na")))
-        self.stateLabel.setText("State: {}".format(info.get("state", "unknown")))
-        self.slideLabel.setText(
-            "Slide: {}/{}".format(
-                info.get("slide_index", "na"), info.get("n_slides", "na")
-            )
-        )
-        self.typeLabel.setText("Slide Type: {}".format(info.get("type", "unknown")))
-        self.sceneLabel.setText(
-            "Scene: {}/{}".format(
-                info.get("scene_index", "na"), info.get("n_scenes", "na")
-            )
-        )
-
-
-class InfoThread(QThread):  # type: ignore
-    def __init__(self) -> None:
-        super().__init__()
-        self.dialog = Info()
-        self.run_flag = True
-
-    def start(self) -> None:
-        super().start()
-
-        self.dialog.show()
-
-    def stop(self) -> None:
-        self.dialog.deleteLater()
-
-
-class App(QWidget):  # type: ignore
-    send_key_signal = Signal(int)
-
-    def __init__(
-        self,
-        *args: Any,
-        config: Config = DEFAULT_CONFIG,
-        fullscreen: bool = False,
-        resolution: Tuple[int, int] = (1980, 1080),
-        hide_mouse: bool = False,
-        aspect_ratio: AspectRatio = AspectRatio.auto,
-        resize_mode: Qt.TransformationMode = Qt.SmoothTransformation,
-        background_color: str = "black",
-        **kwargs: Any,
-    ):
-        super().__init__()
-
-        self.setWindowTitle(WINDOW_NAME)
-        self.icon = QIcon(":/icon.png")
-        self.setWindowIcon(self.icon)
-        self.display_width, self.display_height = resolution
-        self.aspect_ratio = aspect_ratio
-        self.resize_mode = resize_mode
-        self.hide_mouse = hide_mouse
-        self.config = config
-        if self.hide_mouse:
-            self.setCursor(Qt.BlankCursor)
-
-        self.label = QLabel(self)
-
-        if self.aspect_ratio == AspectRatio.auto:
-            self.label.setScaledContents(True)
-        self.label.setAlignment(Qt.AlignCenter)
-        self.label.resize(self.display_width, self.display_height)
-        self.label.setStyleSheet(f"background-color: {background_color}")
-
-        self.pixmap = QPixmap(self.width(), self.height())
-        self.label.setPixmap(self.pixmap)
-        self.label.setMinimumSize(1, 1)
-
-        # create the video capture thread
-        kwargs["config"] = config
-        self.thread = Display(*args, **kwargs)
-        # create the info dialog
-        self.info = Info()
-        self.info.show()
-
-        # info widget will also listen to key presses
-        self.info.keyPressEvent = self.keyPressEvent
-
-        if fullscreen:
-            self.showFullScreen()
-
-        # connect signals
-        self.thread.change_video_signal.connect(self.update_image)
-        self.thread.change_info_signal.connect(self.info.update_info)
-        self.thread.finished.connect(self.closeAll)
-        self.send_key_signal.connect(self.thread.set_key)
-
-        # start the thread
-        self.thread.start()
-
-    def keyPressEvent(self, event: QKeyEvent) -> None:
-        key = event.key()
-        if self.config.HIDE_MOUSE.match(key):
-            if self.hide_mouse:
-                self.setCursor(Qt.ArrowCursor)
-                self.hide_mouse = False
-            else:
-                self.setCursor(Qt.BlankCursor)
-                self.hide_mouse = True
-        # We send key to be handled by video display
-        self.send_key_signal.emit(key)
-        event.accept()
-
-    def closeAll(self) -> None:
-        logger.debug("Closing all QT windows")
-        self.thread.stop()
-        self.info.deleteLater()
-        self.deleteLater()
-
-    def resizeEvent(self, event: QResizeEvent) -> None:
-        if not self.label.hasScaledContents():
-            self.pixmap = self.pixmap.scaled(
-                self.width(), self.height(), self.aspect_ratio.value, self.resize_mode
-            )
-            self.label.setPixmap(self.pixmap)
-        self.label.resize(self.width(), self.height())
-
-    def closeEvent(self, event: QCloseEvent) -> None:
-        self.closeAll()
-        event.accept()
-
-    @Slot(np.ndarray)
-    def update_image(self, cv_img: np.ndarray) -> None:
-        """Updates the (image) label with a new opencv image"""
-        h, w, ch = cv_img.shape
-        bytes_per_line = ch * w
-        qt_img = QImage(cv_img.data, w, h, bytes_per_line, QImage.Format_BGR888)
-
-        if not self.label.hasScaledContents() and (
-            w != self.width() or h != self.height()
-        ):
-            qt_img = qt_img.scaled(
-                self.width(), self.height(), self.aspect_ratio.value, self.resize_mode
-            )
-
-        self.label.setPixmap(QPixmap.fromImage(qt_img))
-
-
-@click.command()
-@click.option(
-    "--folder",
-    metavar="DIRECTORY",
-    default=FOLDER_PATH,
-    type=click.Path(exists=True, file_okay=False, path_type=Path),
-    help="Set slides folder.",
-    show_default=True,
-)
-@click.help_option("-h", "--help")
-@verbosity_option
-def list_scenes(folder: Path) -> None:
-    """List available scenes."""
-
-    for i, scene in enumerate(_list_scenes(folder), start=1):
-        click.secho(f"{i}: {scene}", fg="green")
-
-
-def _list_scenes(folder: Path) -> List[str]:
-    """Lists available scenes in given directory."""
-    scenes = []
-
-    for filepath in folder.glob("*.json"):
-        try:
-            _ = PresentationConfig.parse_file(filepath)
-            scenes.append(filepath.stem)
-        except (
-            Exception
-        ) as e:  # Could not parse this file as a proper presentation config
-            logger.warn(
-                f"Something went wrong with parsing presentation config `{filepath}`: {e}"
-            )
-            pass
-
-    logger.debug(f"Found {len(scenes)} valid scene configuration files in `{folder}`.")
-
-    return scenes
-
-
-def prompt_for_scenes(folder: Path) -> List[str]:
-    """Prompts the user to select scenes within a given folder."""
-
-    scene_choices = dict(enumerate(_list_scenes(folder), start=1))
-
-    for i, scene in scene_choices.items():
-        click.secho(f"{i}: {scene}", fg="green")
-
-    click.echo()
-
-    click.echo("Choose number corresponding to desired scene/arguments.")
-    click.echo("(Use comma separated list for multiple entries)")
-
-    def value_proc(value: Optional[str]) -> List[str]:
-        indices = list(map(int, (value or "").strip().replace(" ", "").split(",")))
-
-        if not all(0 < i <= len(scene_choices) for i in indices):
-            raise click.UsageError("Please only enter numbers displayed on the screen.")
-
-        return [scene_choices[i] for i in indices]
-
-    if len(scene_choices) == 0:
-        raise click.UsageError(
-            "No scenes were found, are you in the correct directory?"
-        )
-
-    while True:
-        try:
-            scenes = click.prompt("Choice(s)", value_proc=value_proc)
-            return scenes
-        except ValueError as e:
-            raise click.UsageError(str(e))
-
-
-def get_scenes_presentation_config(
-    scenes: List[str], folder: Path
-) -> List[PresentationConfig]:
-    """Returns a list of presentation configurations based on the user input."""
-
-    if len(scenes) == 0:
-        scenes = prompt_for_scenes(folder)
-
-    presentation_configs = []
-    for scene in scenes:
-        config_file = folder / f"{scene}.json"
-        if not config_file.exists():
-            raise click.UsageError(
-                f"File {config_file} does not exist, check the scene name and make sure to use Slide as your scene base class"
-            )
-        try:
-            presentation_configs.append(PresentationConfig.parse_file(config_file))
-        except ValidationError as e:
-            raise click.UsageError(str(e))
-
-    return presentation_configs
-
-
-@click.command()
-@click.argument("scenes", nargs=-1)
-@config_path_option
-@click.option(
-    "--folder",
-    metavar="DIRECTORY",
-    default=FOLDER_PATH,
-    type=click.Path(exists=True, file_okay=False, path_type=Path),
-    help="Set slides folder.",
-    show_default=True,
-)
-@click.option("--start-paused", is_flag=True, help="Start paused.")
-@click.option("--fullscreen", is_flag=True, help="Fullscreen mode.")
-@click.option(
-    "-s",
-    "--skip-all",
-    is_flag=True,
-    help="Skip all slides, useful the test if slides are working. Automatically sets `--skip-after-last-slide` to True.",
-)
-@click.option(
-    "-r",
-    "--resolution",
-    metavar="<WIDTH HEIGHT>",
-    type=(int, int),
-    default=(1920, 1080),
-    help="Window resolution WIDTH HEIGHT used if fullscreen is not set. You may manually resize the window afterward.",
-    show_default=True,
-)
-@click.option(
-    "--to",
-    "--record-to",
-    "record_to",
-    metavar="FILE",
-    type=click.Path(dir_okay=False, path_type=Path),
-    default=None,
-    help="If set, the presentation will be recorded into a AVI video file with given name.",
-)
-@click.option(
-    "--exit-after-last-slide",
-    is_flag=True,
-    help="At the end of last slide, the application will be exited.",
-)
-@click.option(
-    "--hide-mouse",
-    is_flag=True,
-    help="Hide mouse cursor.",
-)
-@click.option(
-    "--aspect-ratio",
-    type=click.Choice(ASPECT_RATIO_MODES.keys(), case_sensitive=False),
-    default="auto",
-    help="Set the aspect ratio mode to be used when rescaling video. `'auto'` option is equivalent to `'ignore'`, but can be much faster due to not calling `scaled()` method on every frame.",
-    show_default=True,
-)
-@click.option(
-    "--resize-mode",
-    type=click.Choice(RESIZE_MODES.keys(), case_sensitive=False),
-    default="smooth",
-    help="Set the resize (i.e., transformation) mode to be used when rescaling video.",
-    show_default=True,
-)
-@click.option(
-    "--background-color",
-    "--bgcolor",
-    "background_color",
-    metavar="COLOR",
-    type=str,
-    default="black",
-    help='Set the background color for borders when using "keep" resize mode. Can be any valid CSS color, e.g., "green", "#FF6500" or "rgba(255, 255, 0, .5)".',
-    show_default=True,
-)
-@click.help_option("-h", "--help")
-@verbosity_option
-def present(
-    scenes: List[str],
-    config_path: Path,
-    folder: Path,
-    start_paused: bool,
-    fullscreen: bool,
-    skip_all: bool,
-    resolution: Tuple[int, int],
-    record_to: Optional[Path],
-    exit_after_last_slide: bool,
-    hide_mouse: bool,
-    aspect_ratio: str,
-    resize_mode: str,
-    background_color: str,
-) -> None:
-    """
-    Present SCENE(s), one at a time, in order.
-
-    Each SCENE parameter must be the name of a Manim scene, with existing SCENE.json config file.
-
-    You can present the same SCENE multiple times by repeating the parameter.
-
-    Use `manim-slide list-scenes` to list all available scenes in a given folder.
-    """
-
-    if skip_all:
-        exit_after_last_slide = True
-
-    presentations = [
-        Presentation(presentation_config)
-        for presentation_config in get_scenes_presentation_config(scenes, folder)
-    ]
-
-    if config_path.exists():
-        try:
-            config = Config.parse_file(config_path)
-        except ValidationError as e:
-            raise click.UsageError(str(e))
-    else:
-        logger.debug("No configuration file found, using default configuration.")
-        config = Config()
-
-    if record_to is not None:
-        ext = record_to.suffix
-        if ext.lower() != ".avi":
-            raise click.UsageError(
-                "Recording only support '.avi' extension. For other video formats, please convert the resulting '.avi' file afterwards."
-            )
-
-    app = QApplication(sys.argv)
-    app.setApplicationName("Manim Slides")
-    a = App(
-        presentations,
-        config=config,
-        start_paused=start_paused,
-        fullscreen=fullscreen,
-        skip_all=skip_all,
-        resolution=resolution,
-        record_to=record_to,
-        exit_after_last_slide=exit_after_last_slide,
-        hide_mouse=hide_mouse,
-        aspect_ratio=ASPECT_RATIO_MODES[aspect_ratio],
-        resize_mode=RESIZE_MODES[resize_mode],
-        background_color=background_color,
-    )
-    a.show()
-    sys.exit(app.exec_())

manim_slides/present/__init__.py

@@ -0,0 +1,312 @@
+import signal
+import sys
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+import click
+from click import Context, Parameter
+from pydantic import ValidationError
+from PySide6.QtCore import Qt
+
+from ..commons import config_path_option, folder_path_option, verbosity_option
+from ..config import Config, PresentationConfig
+from ..logger import logger
+from ..qt_utils import qapp
+from .player import Player
+
+ASPECT_RATIO_MODES = {
+    "keep": Qt.KeepAspectRatio,
+    "ignore": Qt.IgnoreAspectRatio,
+}
+
+
+@click.command()
+@folder_path_option
+@click.help_option("-h", "--help")
+@verbosity_option
+def list_scenes(folder: Path) -> None:
+    """List available scenes."""
+    for i, scene in enumerate(_list_scenes(folder), start=1):
+        click.secho(f"{i}: {scene}", fg="green")
+
+
+def _list_scenes(folder: Path) -> List[str]:
+    """List available scenes in given directory."""
+    scenes = []
+
+    for filepath in folder.glob("*.json"):
+        try:
+            _ = PresentationConfig.from_file(filepath)
+            scenes.append(filepath.stem)
+        except (
+            Exception
+        ) as e:  # Could not parse this file as a proper presentation config
+            logger.warn(
+                f"Something went wrong with parsing presentation config `{filepath}`: {e}"
+            )
+
+    logger.debug(f"Found {len(scenes)} valid scene configuration files in `{folder}`.")
+
+    return scenes
+
+
+def prompt_for_scenes(folder: Path) -> List[str]:
+    """Prompt the user to select scenes within a given folder."""
+    scene_choices = dict(enumerate(_list_scenes(folder), start=1))
+
+    for i, scene in scene_choices.items():
+        click.secho(f"{i}: {scene}", fg="green")
+
+    click.echo()
+
+    click.echo("Choose number corresponding to desired scene/arguments.")
+    click.echo("(Use comma separated list for multiple entries)")
+
+    def value_proc(value: Optional[str]) -> List[str]:
+        indices = list(map(int, (value or "").strip().replace(" ", "").split(",")))
+
+        if not all(0 < i <= len(scene_choices) for i in indices):
+            raise click.UsageError("Please only enter numbers displayed on the screen.")
+
+        return [scene_choices[i] for i in indices]
+
+    if len(scene_choices) == 0:
+        raise click.UsageError(
+            "No scenes were found, are you in the correct directory?"
+        )
+
+    while True:
+        try:
+            scenes = click.prompt("Choice(s)", value_proc=value_proc)
+            return scenes  # type: ignore
+        except ValueError as e:
+            raise click.UsageError(str(e)) from None
+
+
+def get_scenes_presentation_config(
+    scenes: List[str], folder: Path
+) -> List[PresentationConfig]:
+    """Return a list of presentation configurations based on the user input."""
+    if len(scenes) == 0:
+        scenes = prompt_for_scenes(folder)
+
+    presentation_configs = []
+    for scene in scenes:
+        config_file = folder / f"{scene}.json"
+        if not config_file.exists():
+            raise click.UsageError(
+                f"File {config_file} does not exist, check the scene name and make sure to use Slide as your scene base class"
+            )
+        try:
+            presentation_configs.append(PresentationConfig.from_file(config_file))
+        except ValidationError as e:
+            raise click.UsageError(str(e)) from None
+
+    return presentation_configs
+
+
+def start_at_callback(
+    ctx: Context, param: Parameter, values: str
+) -> Tuple[Optional[int], ...]:
+    if values == "(None, None)":
+        return (None, None)
+
+    def str_to_int_or_none(value: str) -> Optional[int]:
+        if value.lower().strip() == "":
+            return None
+        else:
+            try:
+                return int(value)
+            except ValueError:
+                raise click.BadParameter(
+                    f"start index can only be an integer or an empty string, not `{value}`",
+                    ctx=ctx,
+                    param=param,
+                ) from None
+
+    values_tuple = values.split(",")
+    n_values = len(values_tuple)
+    if n_values == 2:
+        return tuple(map(str_to_int_or_none, values_tuple))
+
+    raise click.BadParameter(
+        f"exactly 2 arguments are expected but you gave {n_values}, please use commas to separate them",
+        ctx=ctx,
+        param=param,
+    )
+
+
+@click.command()
+@click.argument("scenes", nargs=-1)
+@config_path_option
+@folder_path_option
+@click.option("--start-paused", is_flag=True, help="Start paused.")
+@click.option(
+    "-F",
+    "--full-screen",
+    "--fullscreen",
+    "full_screen",
+    is_flag=True,
+    help="Toggle full screen mode.",
+)
+@click.option(
+    "-s",
+    "--skip-all",
+    is_flag=True,
+    help="Skip all slides, useful the test if slides are working. "
+    "Automatically sets `--exit-after-last-slide` to True.",
+)
+@click.option(
+    "--exit-after-last-slide",
+    is_flag=True,
+    help="At the end of last slide, the application will be exited.",
+)
+@click.option(
+    "-H",
+    "--hide-mouse",
+    is_flag=True,
+    help="Hide mouse cursor.",
+)
+@click.option(
+    "--aspect-ratio",
+    type=click.Choice(["keep", "ignore"], case_sensitive=False),
+    default="keep",
+    help="Set the aspect ratio mode to be used when rescaling the video.",
+    show_default=True,
+)
+@click.option(
+    "--sa",
+    "--start-at",
+    "start_at",
+    metavar="<SCENE,SLIDE>",
+    type=str,
+    callback=start_at_callback,
+    default=(None, None),
+    help="Start presenting at (x, y), equivalent to --sacn x --sasn y, "
+    "and overrides values if not None.",
+)
+@click.option(
+    "--sacn",
+    "--start-at-scene-number",
+    "start_at_scene_number",
+    metavar="INDEX",
+    type=int,
+    default=0,
+    help="Start presenting at a given scene number (0 is first, -1 is last).",
+)
+@click.option(
+    "--sasn",
+    "--start-at-slide-number",
+    "start_at_slide_number",
+    metavar="INDEX",
+    type=int,
+    default=0,
+    help="Start presenting at a given slide number (0 is first, -1 is last).",
+)
+@click.option(
+    "-S",
+    "--screen",
+    "screen_number",
+    metavar="NUMBER",
+    type=int,
+    default=None,
+    help="Present content on the given screen (a.k.a. display).",
+)
+@click.option(
+    "--playback-rate",
+    metavar="RATE",
+    type=float,
+    default=1.0,
+    help="Playback rate of the video slides, see PySide6 docs for details.",
+)
+@click.option(
+    "--next-terminates-loop",
+    "next_terminates_loop",
+    is_flag=True,
+    help="If set, pressing next will turn any looping slide into a play slide.",
+)
+@click.help_option("-h", "--help")
+@verbosity_option
+def present(
+    scenes: List[str],
+    config_path: Path,
+    folder: Path,
+    start_paused: bool,
+    full_screen: bool,
+    skip_all: bool,
+    exit_after_last_slide: bool,
+    hide_mouse: bool,
+    aspect_ratio: str,
+    start_at: Tuple[Optional[int], Optional[int], Optional[int]],
+    start_at_scene_number: int,
+    start_at_slide_number: int,
+    screen_number: Optional[int],
+    playback_rate: float,
+    next_terminates_loop: bool,
+) -> None:
+    """
+    Present SCENE(s), one at a time, in order.
+
+    Each SCENE parameter must be the name of a Manim scene,
+    with existing SCENE.json config file.
+
+    You can present the same SCENE multiple times by repeating the parameter.
+
+    Use ``manim-slide list-scenes`` to list all available
+    scenes in a given folder.
+    """
+    if skip_all:
+        exit_after_last_slide = True
+
+    presentation_configs = get_scenes_presentation_config(scenes, folder)
+
+    if config_path.exists():
+        try:
+            config = Config.from_file(config_path)
+        except ValidationError as e:
+            raise click.UsageError(str(e)) from None
+    else:
+        logger.debug("No configuration file found, using default configuration.")
+        config = Config()
+
+    if start_at[0]:
+        start_at_scene_number = start_at[0]
+
+    if start_at[1]:
+        start_at_slide_number = start_at[1]
+
+    app = qapp()
+    app.setApplicationName("Manim Slides")
+
+    if screen_number is not None:
+        try:
+            screen = app.screens()[screen_number]
+        except IndexError:
+            logger.error(
+                f"Invalid screen number {screen_number}, "
+                f"allowed values are from 0 to {len(app.screens())-1} (incl.)"
+            )
+            screen = None
+    else:
+        screen = None
+
+    player = Player(
+        config,
+        presentation_configs,
+        start_paused=start_paused,
+        full_screen=full_screen,
+        skip_all=skip_all,
+        exit_after_last_slide=exit_after_last_slide,
+        hide_mouse=hide_mouse,
+        aspect_ratio_mode=ASPECT_RATIO_MODES[aspect_ratio],
+        presentation_index=start_at_scene_number,
+        slide_index=start_at_slide_number,
+        screen=screen,
+        playback_rate=playback_rate,
+        next_terminates_loop=next_terminates_loop,
+    )
+
+    player.show()
+
+    signal.signal(signal.SIGINT, signal.SIG_DFL)
+    sys.exit(app.exec())

manim_slides/present/player.py

@@ -0,0 +1,368 @@
+from pathlib import Path
+from typing import Any, List, Optional
+
+from PySide6.QtCore import Qt, QUrl, Signal, Slot
+from PySide6.QtGui import QCloseEvent, QIcon, QKeyEvent, QScreen
+from PySide6.QtMultimedia import QMediaPlayer
+from PySide6.QtMultimediaWidgets import QVideoWidget
+from PySide6.QtWidgets import QDialog, QGridLayout, QLabel, QMainWindow
+
+from ..config import Config, PresentationConfig, SlideConfig
+from ..logger import logger
+from ..resources import *  # noqa: F403
+
+WINDOW_NAME = "Manim Slides"
+
+
+class Info(QDialog):  # type: ignore[misc]
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+
+        layout = QGridLayout()
+        self.scene_label = QLabel()
+        self.slide_label = QLabel()
+
+        layout.addWidget(QLabel("Scene:"), 1, 1)
+        layout.addWidget(QLabel("Slide:"), 2, 1)
+        layout.addWidget(self.scene_label, 1, 2)
+        layout.addWidget(self.slide_label, 2, 2)
+        self.setLayout(layout)
+        self.setFixedWidth(150)
+        self.setFixedHeight(80)
+
+        if parent := self.parent():
+            self.closeEvent = parent.closeEvent
+            self.keyPressEvent = parent.keyPressEvent
+
+
+class Player(QMainWindow):  # type: ignore[misc]
+    presentation_changed: Signal = Signal()
+    slide_changed: Signal = Signal()
+
+    def __init__(
+        self,
+        config: Config,
+        presentation_configs: List[PresentationConfig],
+        *,
+        start_paused: bool = False,
+        full_screen: bool = False,
+        skip_all: bool = False,
+        exit_after_last_slide: bool = False,
+        hide_mouse: bool = False,
+        aspect_ratio_mode: Qt.AspectRatioMode = Qt.KeepAspectRatio,
+        presentation_index: int = 0,
+        slide_index: int = 0,
+        screen: Optional[QScreen] = None,
+        playback_rate: float = 1.0,
+        next_terminates_loop: bool = False,
+    ):
+        super().__init__()
+
+        # Wizard's config
+
+        self.config = config
+
+        # Presentation configs
+
+        self.presentation_configs = presentation_configs
+        self.__current_presentation_index = 0
+        self.__current_slide_index = 0
+
+        self.current_presentation_index = presentation_index
+        self.current_slide_index = slide_index
+
+        self.__current_file: Path = self.current_slide_config.file
+
+        self.__playing_reversed_slide = False
+
+        # Widgets
+
+        if screen:
+            self.setScreen(screen)
+            self.move(screen.geometry().topLeft())
+
+        if full_screen:
+            self.setWindowState(Qt.WindowFullScreen)
+        else:
+            w, h = self.current_presentation_config.resolution
+            geometry = self.geometry()
+            geometry.setWidth(w)
+            geometry.setHeight(h)
+            self.setGeometry(geometry)
+
+        if hide_mouse:
+            self.setCursor(Qt.BlankCursor)
+
+        self.setWindowTitle(WINDOW_NAME)
+        self.icon = QIcon(":/icon.png")
+        self.setWindowIcon(self.icon)
+
+        self.video_widget = QVideoWidget()
+        self.video_widget.setAspectRatioMode(aspect_ratio_mode)
+        self.setCentralWidget(self.video_widget)
+
+        self.media_player = QMediaPlayer(self)
+        self.media_player.setVideoOutput(self.video_widget)
+        self.media_player.setPlaybackRate(playback_rate)
+
+        self.presentation_changed.connect(self.presentation_changed_callback)
+        self.slide_changed.connect(self.slide_changed_callback)
+
+        self.info = Info(parent=self)
+
+        # Connecting key callbacks
+
+        self.config.keys.QUIT.connect(self.close)
+        self.config.keys.PLAY_PAUSE.connect(self.play_pause)
+        self.config.keys.NEXT.connect(self.next)
+        self.config.keys.PREVIOUS.connect(self.previous)
+        self.config.keys.REVERSE.connect(self.reverse)
+        self.config.keys.REPLAY.connect(self.replay)
+        self.config.keys.FULL_SCREEN.connect(self.full_screen)
+        self.config.keys.HIDE_MOUSE.connect(self.hide_mouse)
+
+        self.dispatch = self.config.keys.dispatch_key_function()
+
+        # Misc
+
+        self.exit_after_last_slide = exit_after_last_slide
+        self.next_terminates_loop = next_terminates_loop
+
+        # Setting-up everything
+
+        if skip_all:
+
+            def media_status_changed(status: QMediaPlayer.MediaStatus) -> None:
+                self.media_player.setLoops(1)  # Otherwise looping slides never end
+                if status == QMediaPlayer.EndOfMedia:
+                    self.load_next_slide()
+
+            self.media_player.mediaStatusChanged.connect(media_status_changed)
+
+        else:
+
+            def media_status_changed(status: QMediaPlayer.MediaStatus) -> None:
+                if (
+                    status == QMediaPlayer.EndOfMedia
+                    and self.current_slide_config.auto_next
+                ):
+                    self.load_next_slide()
+
+            self.media_player.mediaStatusChanged.connect(media_status_changed)
+
+        if self.current_slide_config.loop:
+            self.media_player.setLoops(-1)
+
+        self.load_current_media(start_paused=start_paused)
+
+        self.presentation_changed.emit()
+        self.slide_changed.emit()
+
+    """
+    Properties
+    """
+
+    @property
+    def presentations_count(self) -> int:
+        return len(self.presentation_configs)
+
+    @property
+    def current_presentation_index(self) -> int:
+        return self.__current_presentation_index
+
+    @current_presentation_index.setter
+    def current_presentation_index(self, index: int) -> None:
+        if 0 <= index < self.presentations_count:
+            self.__current_presentation_index = index
+        elif -self.presentations_count <= index < 0:
+            self.__current_presentation_index = index + self.presentations_count
+        else:
+            logger.warn(f"Could not set presentation index to {index}.")
+            return
+
+        self.presentation_changed.emit()
+
+    @property
+    def current_presentation_config(self) -> PresentationConfig:
+        return self.presentation_configs[self.current_presentation_index]
+
+    @property
+    def current_slides_count(self) -> int:
+        return len(self.current_presentation_config.slides)
+
+    @property
+    def current_slide_index(self) -> int:
+        return self.__current_slide_index
+
+    @current_slide_index.setter
+    def current_slide_index(self, index: int) -> None:
+        if 0 <= index < self.current_slides_count:
+            self.__current_slide_index = index
+        elif -self.current_slides_count <= index < 0:
+            self.__current_slide_index = index + self.current_slides_count
+        else:
+            logger.warn(f"Could not set slide index to {index}.")
+            return
+
+        self.slide_changed.emit()
+
+    @property
+    def current_slide_config(self) -> SlideConfig:
+        return self.current_presentation_config.slides[self.current_slide_index]
+
+    @property
+    def current_file(self) -> Path:
+        return self.__current_file
+
+    @current_file.setter
+    def current_file(self, file: Path) -> None:
+        self.__current_file = file
+
+    @property
+    def playing_reversed_slide(self) -> bool:
+        return self.__playing_reversed_slide
+
+    @playing_reversed_slide.setter
+    def playing_reversed_slide(self, playing_reversed_slide: bool) -> None:
+        self.__playing_reversed_slide = playing_reversed_slide
+
+    """
+    Loading slides
+    """
+
+    def load_current_media(self, start_paused: bool = False) -> None:
+        url = QUrl.fromLocalFile(self.current_file)
+        self.media_player.setSource(url)
+
+        if start_paused:
+            self.media_player.pause()
+        else:
+            self.media_player.play()
+
+    def load_current_slide(self) -> None:
+        slide_config = self.current_slide_config
+        self.current_file = slide_config.file
+
+        if slide_config.loop:
+            self.media_player.setLoops(-1)
+        else:
+            self.media_player.setLoops(1)
+
+        self.load_current_media()
+
+    def load_previous_slide(self) -> None:
+        self.playing_reversed_slide = False
+
+        if self.current_slide_index > 0:
+            self.current_slide_index -= 1
+        elif self.current_presentation_index > 0:
+            self.current_presentation_index -= 1
+            self.current_slide_index = self.current_slides_count - 1
+        else:
+            logger.info("No previous slide.")
+            return
+
+        self.load_current_slide()
+
+    def load_next_slide(self) -> None:
+        if self.playing_reversed_slide:
+            self.playing_reversed_slide = False
+        elif self.current_slide_index < self.current_slides_count - 1:
+            self.current_slide_index += 1
+        elif self.current_presentation_index < self.presentations_count - 1:
+            self.current_presentation_index += 1
+            self.current_slide_index = 0
+        elif self.exit_after_last_slide:
+            self.close()
+            return
+        else:
+            logger.info("No more slide to play.")
+            return
+
+        self.load_current_slide()
+
+    def load_reversed_slide(self) -> None:
+        self.playing_reversed_slide = True
+        self.current_file = self.current_slide_config.rev_file
+        self.load_current_media()
+
+    """
+    Key callbacks and slots
+    """
+
+    @Slot()
+    def presentation_changed_callback(self) -> None:
+        index = self.current_presentation_index
+        count = self.presentations_count
+        self.info.scene_label.setText(f"{index+1:4d}/{count:4<d}")
+
+    @Slot()
+    def slide_changed_callback(self) -> None:
+        index = self.current_slide_index
+        count = self.current_slides_count
+        self.info.slide_label.setText(f"{index+1:4d}/{count:4<d}")
+
+    def show(self) -> None:
+        super().show()
+        self.info.show()
+
+    @Slot()
+    def close(self) -> None:
+        logger.info("Closing gracefully...")
+        super().close()
+
+    @Slot()
+    def next(self) -> None:
+        if self.media_player.playbackState() == QMediaPlayer.PausedState:
+            self.media_player.play()
+        elif self.next_terminates_loop and self.media_player.loops() != 1:
+            position = self.media_player.position()
+            self.media_player.setLoops(1)
+            self.media_player.stop()
+            self.media_player.setPosition(position)
+            self.media_player.play()
+        else:
+            self.load_next_slide()
+
+    @Slot()
+    def previous(self) -> None:
+        self.load_previous_slide()
+
+    @Slot()
+    def reverse(self) -> None:
+        self.load_reversed_slide()
+
+    @Slot()
+    def replay(self) -> None:
+        self.media_player.setPosition(0)
+        self.media_player.play()
+
+    @Slot()
+    def play_pause(self) -> None:
+        state = self.media_player.playbackState()
+        if state == QMediaPlayer.PausedState:
+            self.media_player.play()
+        elif state == QMediaPlayer.PlayingState:
+            self.media_player.pause()
+
+    @Slot()
+    def full_screen(self) -> None:
+        if self.windowState() == Qt.WindowFullScreen:
+            self.setWindowState(Qt.WindowNoState)
+        else:
+            self.setWindowState(Qt.WindowFullScreen)
+
+    @Slot()
+    def hide_mouse(self) -> None:
+        if self.cursor().shape() == Qt.BlankCursor:
+            self.setCursor(Qt.ArrowCursor)
+        else:
+            self.setCursor(Qt.BlankCursor)
+
+    def closeEvent(self, event: QCloseEvent) -> None:  # noqa: N802
+        self.close()
+
+    def keyPressEvent(self, event: QKeyEvent) -> None:  # noqa: N802
+        key = event.key()
+        self.dispatch(key)
+        event.accept()

manim_slides/qt_utils.py

@@ -0,0 +1,14 @@
+"""Qt utils."""
+
+from PySide6.QtWidgets import QApplication
+
+
+def qapp() -> QApplication:
+    """
+    Return a QApplication instance, creating one
+    if needed.
+    """
+    if app := QApplication.instance():
+        return app
+
+    return QApplication([])

manim_slides/slide.py

@@ -1,240 +0,0 @@
-import os
-import platform
-import shutil
-import subprocess
-from typing import Any, List, Optional
-
-from tqdm import tqdm
-
-from .config import PresentationConfig, SlideConfig, SlideType
-from .defaults import FOLDER_PATH
-from .manim import FFMPEG_BIN, MANIMGL, Scene, ThreeDScene, config, logger
-
-
-def reverse_video_file(src: str, dst: str) -> None:
-    """Reverses a video file, writting the result to `dst`."""
-    command = [FFMPEG_BIN, "-i", src, "-vf", "reverse", dst]
-    logger.debug(" ".join(command))
-    process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    output, error = process.communicate()
-
-    if output:
-        logger.debug(output.decode())
-
-    if error:
-        logger.debug(error.decode())
-
-
-class Slide(Scene):  # type:ignore
-    """
-    Inherits from :class:`manim.scene.scene.Scene` or :class:`manimlib.scene.scene.Scene` and provide necessary tools for slides rendering.
-    """
-
-    def __init__(
-        self, *args: Any, output_folder: str = FOLDER_PATH, **kwargs: Any
-    ) -> None:
-        if MANIMGL:
-            if not os.path.isdir("videos"):
-                os.mkdir("videos")
-            kwargs["file_writer_config"] = {
-                "break_into_partial_movies": True,
-                "output_directory": "",
-                "write_to_movie": True,
-            }
-
-            kwargs["preview"] = False
-
-        super().__init__(*args, **kwargs)
-
-        self.output_folder = output_folder
-        self.slides: List[SlideConfig] = []
-        self.current_slide = 1
-        self.current_animation = 0
-        self.loop_start_animation: Optional[int] = None
-        self.pause_start_animation = 0
-
-    @property
-    def partial_movie_files(self) -> List[str]:
-        """Returns a list of partial movie files, a.k.a animations."""
-        if MANIMGL:
-            from manimlib.utils.file_ops import get_sorted_integer_files
-
-            kwargs = {
-                "remove_non_integer_files": True,
-                "extension": self.file_writer.movie_file_extension,
-            }
-            return get_sorted_integer_files(
-                self.file_writer.partial_movie_directory, **kwargs
-            )
-        else:
-            return self.renderer.file_writer.partial_movie_files
-
-    @property
-    def show_progress_bar(self) -> bool:
-        """Returns True if progress bar should be displayed."""
-        if MANIMGL:
-            return getattr(super(Scene, self), "show_progress_bar", True)
-        else:
-            return config["progress_bar"] != "none"
-
-    @property
-    def leave_progress_bar(self) -> bool:
-        """Returns True if progress bar should be left after completed."""
-        if MANIMGL:
-            return getattr(super(Scene, self), "leave_progress_bars", False)
-        else:
-            return config["progress_bar"] == "leave"
-
-    def play(self, *args: Any, **kwargs: Any) -> None:
-        """Overloads `self.play` and increment animation count."""
-        super().play(*args, **kwargs)
-        self.current_animation += 1
-
-    def pause(self) -> None:
-        """Creates a new slide with previous animations."""
-        self.slides.append(
-            SlideConfig(
-                type=SlideType.slide,
-                start_animation=self.pause_start_animation,
-                end_animation=self.current_animation,
-                number=self.current_slide,
-            )
-        )
-        self.current_slide += 1
-        self.pause_start_animation = self.current_animation
-
-    def add_last_slide(self) -> None:
-        """Adds a 'last' slide to the end of slides."""
-
-        if (
-            len(self.slides) > 0
-            and self.current_animation == self.slides[-1].end_animation
-        ):
-            self.slides[-1].type = SlideType.last
-            return
-
-        self.slides.append(
-            SlideConfig(
-                type=SlideType.last,
-                start_animation=self.pause_start_animation,
-                end_animation=self.current_animation,
-                number=self.current_slide,
-            )
-        )
-
-    def start_loop(self) -> None:
-        """Starts a loop."""
-        assert self.loop_start_animation is None, "You cannot nest loops"
-        self.loop_start_animation = self.current_animation
-
-    def end_loop(self) -> None:
-        """Ends an existing loop."""
-        assert (
-            self.loop_start_animation is not None
-        ), "You have to start a loop before ending it"
-        self.slides.append(
-            SlideConfig(
-                type=SlideType.loop,
-                start_animation=self.loop_start_animation,
-                end_animation=self.current_animation,
-                number=self.current_slide,
-            )
-        )
-        self.current_slide += 1
-        self.loop_start_animation = None
-        self.pause_start_animation = self.current_animation
-
-    def save_slides(self, use_cache: bool = True) -> None:
-        """
-        Saves slides, optionally using cached files.
-
-        Note that cached files only work with Manim.
-        """
-        self.add_last_slide()
-
-        if not os.path.exists(self.output_folder):
-            os.mkdir(self.output_folder)
-
-        files_folder = os.path.join(self.output_folder, "files")
-        if not os.path.exists(files_folder):
-            os.mkdir(files_folder)
-
-        scene_name = type(self).__name__
-        scene_files_folder = os.path.join(files_folder, scene_name)
-
-        old_animation_files = set()
-
-        if not os.path.exists(scene_files_folder):
-            os.mkdir(scene_files_folder)
-        elif not use_cache:
-            shutil.rmtree(scene_files_folder)
-            os.mkdir(scene_files_folder)
-        else:
-            old_animation_files.update(os.listdir(scene_files_folder))
-
-        files = []
-        for src_file in tqdm(
-            self.partial_movie_files,
-            desc=f"Copying animation files to '{scene_files_folder}' and generating reversed animations",
-            leave=self.leave_progress_bar,
-            ascii=True if platform.system() == "Windows" else None,
-            disable=not self.show_progress_bar,
-        ):
-            filename = os.path.basename(src_file)
-            rev_filename = "{}_reversed{}".format(*os.path.splitext(filename))
-
-            dst_file = os.path.join(scene_files_folder, filename)
-            # We only copy animation if it was not present
-            if filename in old_animation_files:
-                old_animation_files.remove(filename)
-            else:
-                shutil.copyfile(src_file, dst_file)
-
-            # We only reverse video if it was not present
-            if rev_filename in old_animation_files:
-                old_animation_files.remove(rev_filename)
-            else:
-                rev_file = os.path.join(scene_files_folder, rev_filename)
-                reverse_video_file(src_file, rev_file)
-
-            files.append(dst_file)
-
-        logger.info(
-            f"Copied {len(files)} animations to '{os.path.abspath(scene_files_folder)}' and generated reversed animations"
-        )
-
-        slide_path = os.path.join(self.output_folder, "%s.json" % (scene_name,))
-
-        with open(slide_path, "w") as f:
-            f.write(PresentationConfig(slides=self.slides, files=files).json(indent=2))
-
-        logger.info(
-            f"Slide '{scene_name}' configuration written in '{os.path.abspath(slide_path)}'"
-        )
-
-    def run(self, *args: Any, **kwargs: Any) -> None:
-        """MANIMGL renderer"""
-        super().run(*args, **kwargs)
-        self.save_slides(use_cache=False)
-
-    def render(self, *args: Any, **kwargs: Any) -> None:
-        """MANIM render"""
-        # We need to disable the caching limit since we rely on intermidiate files
-        max_files_cached = config["max_files_cached"]
-        config["max_files_cached"] = float("inf")
-
-        super().render(*args, **kwargs)
-
-        config["max_files_cached"] = max_files_cached
-
-        self.save_slides()
-
-
-class ThreeDSlide(Slide, ThreeDScene):  # type: ignore
-    """
-    Inherits from :class:`Slide` and :class:`manim.scene.three_d_scene.ThreeDScene` or :class:`manimlib.scene.three_d_scene.ThreeDScene` and provide necessary tools for slides rendering.
-
-    .. note:: ManimGL does not need ThreeDScene for 3D rendering in recent versions, see `example.py`.
-    """
-
-    pass

manim_slides/slide/__init__.py

@@ -0,0 +1,63 @@
+__all__ = [
+    "MANIM",
+    "MANIMGL",
+    "API_NAME",
+    "Slide",
+    "ThreeDSlide",
+]
+
+
+import os
+import sys
+
+
+class ManimApiNotFoundError(ImportError):
+    """Error raised if specified manim API could be imported."""
+
+    _msg = "Could not import the specified manim API"
+
+    def __init__(self) -> None:
+        super().__init__(self._msg)
+
+
+API_NAMES = {
+    "manim": "manim",
+    "manimce": "manim",
+    "manimlib": "manimlib",
+    "manimgl": "manimlib",
+}
+
+MANIM_API: str = "MANIM_API"
+FORCE_MANIM_API: str = "FORCE_" + MANIM_API
+
+API: str = os.environ.get(MANIM_API, "manim").lower()
+
+
+if API not in API_NAMES:
+    raise ImportError(
+        f"Specified MANIM_API={API!r} is not in valid options: " f"{API_NAMES}",
+    )
+
+API_NAME = API_NAMES[API]
+
+if not os.environ.get(FORCE_MANIM_API):
+    if "manim" in sys.modules:
+        API_NAME = "manim"
+    elif "manimlib" in sys.modules:
+        API_NAME = "manimlib"
+
+MANIM: bool = API_NAME == "manim"
+MANIMGL: bool = API_NAME == "manimlib"
+
+if MANIM:
+    try:
+        from .manim import Slide, ThreeDSlide
+    except ImportError as e:
+        raise ManimApiNotFoundError from e
+elif MANIMGL:
+    try:
+        from .manimlib import Slide, ThreeDSlide
+    except ImportError as e:
+        raise ManimApiNotFoundError from e
+else:
+    raise ManimApiNotFoundError

manim_slides/slide/animation.py

@@ -0,0 +1,159 @@
+"""
+Additional animations for Manim objects.
+
+Like with Manim, animations are classes that must be put inside a
+:meth:`Scene.play<manim.scene.scene.Scene.play>` call.
+
+For each of the provided classes, there exists a method variant
+that directly calls ``self.play(Animation(...))``, see
+:class:`Slide<manim_slides.slide.Slide>`.
+"""
+
+__all__ = ["Wipe", "Zoom"]
+
+from typing import Any, Mapping, Optional, Sequence
+
+import numpy as np
+
+from . import MANIM
+
+if MANIM:
+    from manim import LEFT, AnimationGroup, FadeIn, FadeOut
+    from manim.mobject.mobject import Mobject
+else:
+    from manimlib import LEFT, AnimationGroup, FadeIn, FadeOut
+
+    Mobject = Any
+
+
+class Wipe(AnimationGroup):  # type: ignore[misc]
+    """
+    Creates a wipe animation that will shift all the current objects and future objects
+    by a given value.
+
+    :param current: A sequence of mobjects to remove from the scene.
+    :param future: A sequence of mobjects to add to the scene.
+    :param shift: The shift vector, used for both fading in and out.
+    :param fade_in_kwargs: Keyword arguments passed to
+        :class:`FadeIn<manim.animation.fading.FadeIn>`.
+    :param fade_out_kwargs: Keyword arguments passed to
+        :class:`FadeOut<manim.animation.fading.FadeOut>`.
+    :param kwargs: Keyword arguments passed to
+        :class:`AnimationGroup<manim.animation.composition.AnimationGroup>`.
+
+    Examples
+    --------
+    .. manim-slides:: WipeClassExample
+
+        from manim import *
+        from manim_slides import Slide
+        from manim_slides.slide.animation import Wipe
+
+        class WipeClassExample(Slide):
+            def construct(self):
+                circle = Circle(radius=3, color=BLUE)
+                square = Square()
+
+                self.play(FadeIn(circle))
+                self.next_slide()
+
+                self.play(Wipe(circle, square, shift=3 * LEFT))
+    """
+
+    def __init__(
+        self,
+        current: Optional[Sequence[Mobject]] = None,
+        future: Optional[Sequence[Mobject]] = None,
+        shift: np.ndarray = LEFT,
+        fade_in_kwargs: Optional[Mapping[str, Any]] = None,
+        fade_out_kwargs: Optional[Mapping[str, Any]] = None,
+        **kwargs: Any,
+    ):
+        animations = []
+
+        if future:
+            if fade_in_kwargs is None:
+                fade_in_kwargs = {}
+
+            for mobject in future:
+                animations.append(FadeIn(mobject, shift=shift, **fade_in_kwargs))
+
+        if current:
+            if fade_out_kwargs is None:
+                fade_out_kwargs = {}
+
+            for mobject in current:
+                animations.append(FadeOut(mobject, shift=shift, **fade_out_kwargs))
+
+        super().__init__(*animations, **kwargs)
+
+
+class Zoom(AnimationGroup):  # type: ignore[misc]
+    """
+    Creates a zoom animation that will fade out all the current objects, and fade in all
+    the future objects. Objects are faded in a direction that goes towards the camera.
+
+    :param current: A sequence of mobjects to remove from the scene.
+    :param future: A sequence of mobjects to add to the scene.
+    :param scale: How much the objects are scaled (up or down).
+    :param out: If set, the objects fade in the opposite direction.
+    :param fade_in_kwargs: Keyword arguments passed to
+        :class:`FadeIn<manim.animation.fading.FadeIn>`.
+    :param fade_out_kwargs: Keyword arguments passed to
+        :class:`FadeOut<manim.animation.fading.FadeOut>`.
+    :param kwargs: Keyword arguments passed to
+        :class:`AnimationGroup<manim.animation.composition.AnimationGroup>`.
+
+    Examples
+    --------
+    .. manim-slides:: ZoomClassExample
+
+        from manim import *
+        from manim_slides import Slide
+        from manim_slides.slide.animation import Zoom
+
+        class ZoomClassExample(Slide):
+            def construct(self):
+                circles = [Circle(radius=i) for i in range(1, 4)]
+
+                self.play(FadeIn(circles[0]))
+                self.next_slide()
+
+                for i in range(2):
+                    self.play(Zoom(circles[i], circles[i+1]))
+                    self.next_slide()
+    """
+
+    def __init__(
+        self,
+        current: Optional[Sequence[Mobject]] = None,
+        future: Optional[Sequence[Mobject]] = None,
+        scale: float = 4.0,
+        out: bool = False,
+        fade_in_kwargs: Optional[Mapping[str, Any]] = None,
+        fade_out_kwargs: Optional[Mapping[str, Any]] = None,
+        **kwargs: Any,
+    ) -> None:
+        scale_in = 1.0 / scale
+        scale_out = scale
+
+        if out:
+            scale_in, scale_out = scale_out, scale_in
+
+        animations = []
+
+        if future:
+            if fade_in_kwargs is None:
+                fade_in_kwargs = {}
+
+            for mobject in future:
+                animations.append(FadeIn(mobject, scale=scale_in, **fade_in_kwargs))
+
+        if current:
+            if fade_out_kwargs is None:
+                fade_out_kwargs = {}
+
+            for mobject in current:
+                animations.append(FadeOut(mobject, scale=scale_out, **fade_out_kwargs))
+
+        super().__init__(*animations, **kwargs)

manim_slides/slide/base.py

@@ -0,0 +1,561 @@
+__all__ = ["BaseSlide"]
+
+import platform
+from abc import abstractmethod
+from pathlib import Path
+from typing import Any, List, MutableMapping, Optional, Sequence, Tuple, ValuesView
+
+import numpy as np
+from tqdm import tqdm
+
+from ..config import PresentationConfig, PreSlideConfig, SlideConfig
+from ..defaults import FFMPEG_BIN, FOLDER_PATH
+from ..logger import logger
+from ..utils import concatenate_video_files, merge_basenames, reverse_video_file
+from . import MANIM
+
+if MANIM:
+    from manim.mobject.mobject import Mobject
+else:
+    Mobject = Any
+
+LEFT: np.ndarray = np.array([-1.0, 0.0, 0.0])
+
+
+class BaseSlide:
+    def __init__(
+        self, *args: Any, output_folder: Path = FOLDER_PATH, **kwargs: Any
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self._output_folder: Path = output_folder
+        self._slides: List[PreSlideConfig] = []
+        self._pre_slide_config_kwargs: MutableMapping[str, Any] = {}
+        self._current_slide = 1
+        self._current_animation = 0
+        self._start_animation = 0
+        self._canvas: MutableMapping[str, Mobject] = {}
+        self._wait_time_between_slides = 0.0
+
+    @property
+    def _ffmpeg_bin(self) -> Path:
+        """Return the path to the ffmpeg binaries."""
+        return FFMPEG_BIN
+
+    @property
+    @abstractmethod
+    def _frame_height(self) -> float:
+        """Return the scene's frame height."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def _frame_width(self) -> float:
+        """Return the scene's frame width."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def _background_color(self) -> str:
+        """Return the scene's background color."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def _resolution(self) -> Tuple[int, int]:
+        """Return the scene's resolution used during rendering."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def _partial_movie_files(self) -> List[Path]:
+        """Return a list of partial movie files, a.k.a animations."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def _show_progress_bar(self) -> bool:
+        """Return True if progress bar should be displayed."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def _leave_progress_bar(self) -> bool:
+        """Return True if progress bar should be left after completed."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def _start_at_animation_number(self) -> Optional[int]:
+        """If set, return the animation number at which rendering start."""
+        raise NotImplementedError
+
+    @property
+    def canvas(self) -> MutableMapping[str, Mobject]:
+        """
+        Return the canvas associated to the current slide.
+
+        The canvas is a mapping between names and Mobjects,
+        for objects that are assumed to stay in multiple slides.
+
+        For example, a section title or a slide number.
+
+        Examples
+        --------
+        .. manim-slides:: CanvasExample
+
+            from manim import *
+            from manim_slides import Slide
+
+            class CanvasExample(Slide):
+                def update_canvas(self):
+                    self.counter += 1
+                    old_slide_number = self.canvas["slide_number"]
+                    new_slide_number = Text(f"{self.counter}").move_to(old_slide_number)
+                    self.play(Transform(old_slide_number, new_slide_number))
+
+                def construct(self):
+                    title = Text("My Title").to_corner(UL)
+
+                    self.counter = 1
+                    slide_number = Text("1").to_corner(DL)
+
+                    self.add_to_canvas(title=title, slide_number=slide_number)
+
+                    self.play(FadeIn(title), FadeIn(slide_number))
+                    self.next_slide()
+
+                    circle = Circle(radius=2)
+                    dot = Dot()
+
+                    self.update_canvas()
+                    self.play(Create(circle))
+                    self.play(MoveAlongPath(dot, circle))
+
+                    self.next_slide()
+                    self.update_canvas()
+
+                    square = Square()
+
+                    self.wipe(self.mobjects_without_canvas, square)
+                    self.next_slide()
+
+                    self.update_canvas()
+                    self.play(
+                        Transform(
+                            self.canvas["title"],
+                            Text("New Title").to_corner(UL)
+                        )
+                    )
+                    self.next_slide()
+
+                    self.remove_from_canvas("title", "slide_number")
+                    self.wipe(self.mobjects_without_canvas, [])
+        """
+        return self._canvas
+
+    def add_to_canvas(self, **objects: Mobject) -> None:
+        """
+        Add objects to the canvas, using key values as names.
+
+        :param objects: A mapping between names and Mobjects.
+
+        .. note::
+
+            This method does not actually do anything in terms of
+            animations. You must still call :code:`self.add` or
+            play some animation that introduces each Mobject for
+            it to appear. The same applies when removing objects.
+        """
+        self._canvas.update(objects)
+
+    def remove_from_canvas(self, *names: str) -> None:
+        """Remove objects from the canvas."""
+        for name in names:
+            self._canvas.pop(name)
+
+    @property
+    def canvas_mobjects(self) -> ValuesView[Mobject]:
+        """Return Mobjects contained in the canvas."""
+        return self.canvas.values()
+
+    @property
+    def mobjects_without_canvas(self) -> Sequence[Mobject]:
+        """
+        Return the list of objects contained in the scene, minus those present in
+        the canvas.
+        """
+        return [
+            mobject for mobject in self.mobjects if mobject not in self.canvas_mobjects  # type: ignore[attr-defined]
+        ]
+
+    @property
+    def wait_time_between_slides(self) -> float:
+        r"""
+        Return the wait duration (in seconds) added between two slides.
+
+        By default, this value is set to 0.
+
+        Setting this value to something bigger than 0 will result in a
+        :code:`self.wait` animation called at the end of every slide.
+
+        .. note::
+            This is useful because animations are usually only terminated
+            when a new animation is played. You can observe the small difference
+            in the examples below: the circle is not fully complete in the first
+            slide of the first example, but well in the second example.
+
+        Examples
+        --------
+        .. manim-slides:: WithoutWaitExample
+
+            from manim import *
+            from manim_slides import Slide
+
+            class WithoutWaitExample(Slide):
+                def construct(self):
+                    circle = Circle(radius=2)
+                    arrow = Arrow().next_to(circle, RIGHT).scale(-1)
+                    text = Text("Small\ngap").next_to(arrow, RIGHT)
+
+                    self.play(Create(arrow), FadeIn(text))
+                    self.play(Create(circle))
+                    self.next_slide()
+
+                    self.play(FadeOut(circle))
+
+        .. manim-slides:: WithWaitExample
+
+            from manim import *
+            from manim_slides import Slide
+
+            class WithWaitExample(Slide):
+                def construct(self):
+                    self.wait_time_between_slides = 0.1  # A small value > 1 / FPS
+                    circle = Circle(radius=2)
+                    arrow = Arrow().next_to(circle, RIGHT).scale(-1)
+                    text = Text("No more\ngap").next_to(arrow, RIGHT)
+
+                    self.play(Create(arrow), FadeIn(text))
+                    self.play(Create(circle))
+                    self.next_slide()
+
+                    self.play(FadeOut(circle))
+        """
+        return self._wait_time_between_slides
+
+    @wait_time_between_slides.setter
+    def wait_time_between_slides(self, wait_time: float) -> None:
+        self._wait_time_between_slides = max(wait_time, 0.0)
+
+    def play(self, *args: Any, **kwargs: Any) -> None:
+        """Overload `self.play` and increment animation count."""
+        super().play(*args, **kwargs)  # type: ignore[misc]
+        self._current_animation += 1
+
+    def next_slide(
+        self, *, loop: bool = False, auto_next: bool = False, **kwargs: Any
+    ) -> None:
+        """
+        Create a new slide with previous animations, and setup options
+        for the next slide.
+
+        This usually means that the user will need to press some key before the
+        next slide is played. By default, this is the right arrow key.
+
+        :param args:
+            Positional arguments to be passed to
+            :meth:`Scene.next_section<manim.scene.scene.Scene.next_section>`,
+            or ignored if `manimlib` API is used.
+        :param loop:
+            If set, next slide will be looping.
+        :param auto_next:
+            If set, next slide will play immediately play the next slide
+            upon terminating.
+
+            Note that this is only supported by ``manim-slides present``
+            and ``manim-slides convert --to=html``.
+        :param kwargs:
+            Keyword arguments to be passed to
+            :meth:`Scene.next_section<manim.scene.scene.Scene.next_section>`,
+            or ignored if `manimlib` API is used.
+
+        .. note::
+
+            Calls to :func:`next_slide` at the very beginning or at the end are
+            not needed, since they are automatically added.
+
+        .. warning::
+
+            When rendered with RevealJS, loops cannot be in the first nor
+            the last slide.
+
+        .. seealso::
+
+            When using ``manim`` API, this method will also call
+            :meth:`Scene.next_section<manim.scene.scene.Scene.next_section>`.
+
+        Examples
+        --------
+        The following contains 3 slides:
+
+        #. the first with nothing on it;
+        #. the second with "Hello World!" fading in;
+        #. and the last with the text fading out;
+
+        .. manim-slides:: NextSlideExample
+
+            from manim import *
+            from manim_slides import Slide
+
+            class NextSlideExample(Slide):
+                def construct(self):
+                    text = Text("Hello World!")
+
+                    self.play(FadeIn(text))
+
+                    self.next_slide()
+                    self.play(FadeOut(text))
+
+        The following contains one slide that will loop endlessly.
+
+        .. manim-slides:: LoopExample
+
+            from manim import *
+            from manim_slides import Slide
+
+            class LoopExample(Slide):
+                def construct(self):
+                    dot = Dot(color=BLUE, radius=1)
+
+                    self.play(FadeIn(dot))
+
+                    self.next_slide(loop=True)
+
+                    self.play(Indicate(dot, scale_factor=2))
+
+                    self.next_slide()
+
+                    self.play(FadeOut(dot))
+
+        The following contains one slide that triggers the next slide
+        upon terminating.
+
+        .. manim-slides:: AutoNextExample
+
+            from manim import *
+            from manim_slides import Slide
+
+            class AutoNextExample(Slide):
+                def construct(self):
+                    square = Square(color=RED, side_length=2)
+
+                    self.play(GrowFromCenter(square))
+
+                    self.next_slide(auto_next=True)
+
+                    self.play(Wiggle(square))
+
+                    self.next_slide()
+
+                    self.wipe(square)
+        """
+        if self._current_animation > self._start_animation:
+            if self.wait_time_between_slides > 0.0:
+                self.wait(self.wait_time_between_slides)  # type: ignore[attr-defined]
+
+            self._slides.append(
+                PreSlideConfig(
+                    start_animation=self._start_animation,
+                    end_animation=self._current_animation,
+                    **self._pre_slide_config_kwargs,
+                )
+            )
+
+            self._current_slide += 1
+
+        self._pre_slide_config_kwargs = dict(loop=loop, auto_next=auto_next)
+        self._start_animation = self._current_animation
+
+    def _add_last_slide(self) -> None:
+        """Add a 'last' slide to the end of slides."""
+        if (
+            len(self._slides) > 0
+            and self._current_animation == self._slides[-1].end_animation
+        ):
+            return
+
+        self._slides.append(
+            PreSlideConfig(
+                start_animation=self._start_animation,
+                end_animation=self._current_animation,
+                **self._pre_slide_config_kwargs,
+            )
+        )
+
+    def _save_slides(self, use_cache: bool = True) -> None:
+        """
+        Save slides, optionally using cached files.
+
+        Note that cached files only work with Manim.
+        """
+        self._add_last_slide()
+
+        files_folder = self._output_folder / "files"
+
+        scene_name = str(self)
+        scene_files_folder = files_folder / scene_name
+
+        scene_files_folder.mkdir(parents=True, exist_ok=True)
+
+        files: List[Path] = self._partial_movie_files
+
+        # We must filter slides that end before the animation offset
+        if offset := self._start_at_animation_number:
+            self._slides = [
+                slide for slide in self._slides if slide.end_animation > offset
+            ]
+            for slide in self._slides:
+                slide.start_animation = max(0, slide.start_animation - offset)
+                slide.end_animation -= offset
+
+        slides: List[SlideConfig] = []
+
+        for pre_slide_config in tqdm(
+            self._slides,
+            desc=f"Concatenating animation files to '{scene_files_folder}' and generating reversed animations",
+            leave=self._leave_progress_bar,
+            ascii=True if platform.system() == "Windows" else None,
+            disable=not self._show_progress_bar,
+        ):
+            slide_files = files[pre_slide_config.slides_slice]
+
+            file = merge_basenames(slide_files)
+            dst_file = scene_files_folder / file.name
+            rev_file = scene_files_folder / f"{file.stem}_reversed{file.suffix}"
+
+            # We only concat animations if it was not present
+            if not use_cache or not dst_file.exists():
+                concatenate_video_files(self._ffmpeg_bin, slide_files, dst_file)
+
+            # We only reverse video if it was not present
+            if not use_cache or not rev_file.exists():
+                reverse_video_file(self._ffmpeg_bin, dst_file, rev_file)
+
+            slides.append(
+                SlideConfig.from_pre_slide_config_and_files(
+                    pre_slide_config, dst_file, rev_file
+                )
+            )
+
+        logger.info(
+            f"Generated {len(slides)} slides to '{scene_files_folder.absolute()}'"
+        )
+
+        slide_path = self._output_folder / f"{scene_name}.json"
+
+        PresentationConfig(
+            slides=slides,
+            resolution=self._resolution,
+            background_color=self._background_color,
+        ).to_file(slide_path)
+
+        logger.info(
+            f"Slide '{scene_name}' configuration written in '{slide_path.absolute()}'"
+        )
+
+    def wipe(
+        self,
+        *args: Any,
+        direction: np.ndarray = LEFT,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Play a wipe animation that will shift all the current objects outside of the
+        current scene's scope, and all the future objects inside.
+
+        :param args: Positional arguments passed to
+            :class:`Wipe<manim_slides.slide.animation.Wipe>`.
+        :param direction: The wipe direction, that will be scaled by the scene size.
+        :param kwargs: Keyword arguments passed to
+            :class:`Wipe<manim_slides.slide.animation.Wipe>`.
+
+        Examples
+        --------
+        .. manim-slides:: WipeExample
+
+            from manim import *
+            from manim_slides import Slide
+
+            class WipeExample(Slide):
+                def construct(self):
+                    circle = Circle(radius=3, color=BLUE)
+                    square = Square()
+                    text = Text("This is a wipe example").next_to(square, DOWN)
+                    beautiful = Text("Beautiful, no?")
+
+                    self.play(FadeIn(circle))
+                    self.next_slide()
+
+                    self.wipe(circle, Group(square, text))
+                    self.next_slide()
+
+                    self.wipe(Group(square, text), beautiful, direction=UP)
+                    self.next_slide()
+
+                    self.wipe(beautiful, circle, direction=DOWN + RIGHT)
+        """
+        from .animation import Wipe
+
+        shift_amount = np.asarray(direction) * np.array(
+            [self._frame_width, self._frame_height, 0.0]
+        )
+
+        kwargs.setdefault("shift", shift_amount)
+
+        animation = Wipe(
+            *args,
+            **kwargs,
+        )
+
+        self.play(animation)
+
+    def zoom(
+        self,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Play a zoom animation that will fade out all the current objects, and fade in
+        all the future objects. Objects are faded in a direction that goes towards the
+        camera.
+
+        :param args: Positional arguments passed to
+            :class:`Zoom<manim_slides.slide.animation.Zoom>`.
+        :param kwargs: Keyword arguments passed to
+            :class:`Zoom<manim_slides.slide.animation.Zoom>`.
+
+        Examples
+        --------
+        .. manim-slides:: ZoomExample
+
+            from manim import *
+            from manim_slides import Slide
+
+            class ZoomExample(Slide):
+                def construct(self):
+                    circle = Circle(radius=3, color=BLUE)
+                    square = Square()
+
+                    self.play(FadeIn(circle))
+                    self.next_slide()
+
+                    self.zoom(circle, square)
+                    self.next_slide()
+
+                    self.zoom(square, circle, out=True, scale=10.0)
+        """
+        from .animation import Zoom
+
+        animation = Zoom(*args, **kwargs)
+
+        self.play(animation)

manim_slides/slide/manim.py

@@ -0,0 +1,150 @@
+from pathlib import Path
+from typing import Any, List, Optional, Tuple
+
+from manim import Scene, ThreeDScene, config
+
+from .base import BaseSlide
+
+
+class Slide(BaseSlide, Scene):  # type: ignore[misc]
+    """
+    Inherits from :class:`Scene<manim.scene.scene.Scene>` and provide necessary tools
+    for slides rendering.
+    """
+
+    @property
+    def _ffmpeg_bin(self) -> Path:
+        # Prior to v0.16.0.post0,
+        # ffmpeg was stored as a constant in manim.constants
+        try:
+            return Path(config.ffmpeg_executable)
+        except AttributeError:
+            return super()._ffmpeg_bin
+
+    @property
+    def _frame_height(self) -> float:
+        return config["frame_height"]  # type: ignore
+
+    @property
+    def _frame_width(self) -> float:
+        return config["frame_width"]  # type: ignore
+
+    @property
+    def _background_color(self) -> str:
+        color = config["background_color"]
+        if hex_color := getattr(color, "hex", None):
+            return hex_color  # type: ignore
+        else:  # manim>=0.18, see https://github.com/ManimCommunity/manim/pull/3020
+            return color.to_hex()  # type: ignore
+
+    @property
+    def _resolution(self) -> Tuple[int, int]:
+        return config["pixel_width"], config["pixel_height"]
+
+    @property
+    def _partial_movie_files(self) -> List[Path]:
+        # When rendering with -na,b (manim only)
+        # the animations not in [a,b] will be skipped,
+        # but animation before a will have a None source file.
+        return [
+            Path(file)
+            for file in self.renderer.file_writer.partial_movie_files
+            if file is not None
+        ]
+
+    @property
+    def _show_progress_bar(self) -> bool:
+        return config["progress_bar"] != "none"  # type: ignore
+
+    @property
+    def _leave_progress_bar(self) -> bool:
+        return config["progress_bar"] == "leave"  # type: ignore
+
+    @property
+    def _start_at_animation_number(self) -> Optional[int]:
+        return config["from_animation_number"]  # type: ignore
+
+    def next_section(self, *args: Any, **kwargs: Any) -> None:
+        """
+        Alias to :meth:`next_slide`.
+
+        :param args:
+            Positional arguments to be passed to :meth:`next_slide`.
+        :param kwargs:
+            Keyword arguments to be passed to :meth:`next_slide`.
+
+        .. attention::
+
+            This method is only available when using ``manim`` API.
+        """
+        self.next_slide(*args, **kwargs)
+
+    def next_slide(
+        self, *args: Any, loop: bool = False, auto_next: bool = False, **kwargs: Any
+    ) -> None:
+        Scene.next_section(self, *args, **kwargs)
+        BaseSlide.next_slide(self, loop=loop, auto_next=auto_next)
+
+    def render(self, *args: Any, **kwargs: Any) -> None:
+        """MANIM render."""
+        # We need to disable the caching limit since we rely on intermediate files
+        max_files_cached = config["max_files_cached"]
+        config["max_files_cached"] = float("inf")
+
+        super().render(*args, **kwargs)
+
+        config["max_files_cached"] = max_files_cached
+
+        self._save_slides()
+
+
+class ThreeDSlide(Slide, ThreeDScene):  # type: ignore[misc]
+    """
+    Inherits from :class:`Slide` and
+    :class:`ThreeDScene<manim.scene.three_d_scene.ThreeDScene>` and provide necessary
+    tools for slides rendering.
+
+    Examples
+    --------
+    .. manim-slides:: ThreeDExample
+
+        from manim import *
+        from manim_slides import ThreeDSlide
+
+        class ThreeDExample(ThreeDSlide):
+            def construct(self):
+                title = Text("A 2D Text")
+
+                self.play(FadeIn(title))
+                self.next_slide()
+
+                sphere = Sphere([0, 0, -3])
+
+                self.move_camera(phi=PI/3, theta=-PI/4, distance=7)
+                self.play(
+                    GrowFromCenter(sphere),
+                    Transform(title, Text("A 3D Text"))
+                )
+                self.next_slide()
+
+                bye = Text("Bye!")
+
+                self.next_slide(loop=True)
+                self.wipe(
+                    self.mobjects_without_canvas,
+                    [bye],
+                    direction=UP
+                )
+                self.wait(.5)
+                self.wipe(
+                    self.mobjects_without_canvas,
+                    [title, sphere],
+                    direction=DOWN
+                )
+                self.wait(.5)
+                self.next_slide()
+
+                self.play(*[FadeOut(mobject) for mobject in self.mobjects])
+    """
+
+    pass

manim_slides/slide/manimlib.py

@@ -0,0 +1,72 @@
+from pathlib import Path
+from typing import Any, ClassVar, Dict, List, Optional, Tuple
+
+from manimlib import Scene, ThreeDCamera
+from manimlib.utils.file_ops import get_sorted_integer_files
+
+from .base import BaseSlide
+
+
+class Slide(BaseSlide, Scene):  # type: ignore[misc]
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        kwargs.setdefault("file_writer_config", {}).update(
+            skip_animations=True,
+            break_into_partial_movies=True,
+            write_to_movie=True,
+        )
+
+        kwargs["preview"] = False  # Avoid opening a preview window
+        super().__init__(*args, **kwargs)
+
+    @property
+    def _frame_height(self) -> float:
+        return self.camera.frame.get_height()  # type: ignore
+
+    @property
+    def _frame_width(self) -> float:
+        return self.camera.frame.get_width()  # type: ignore
+
+    @property
+    def _background_color(self) -> str:
+        return self.camera_config["background_color"].hex  # type: ignore
+
+    @property
+    def _resolution(self) -> Tuple[int, int]:
+        return self.camera_config["pixel_width"], self.camera_config["pixel_height"]
+
+    @property
+    def _partial_movie_files(self) -> List[Path]:
+        kwargs = {
+            "remove_non_integer_files": True,
+            "extension": self.file_writer.movie_file_extension,
+        }
+        return [
+            Path(file)
+            for file in get_sorted_integer_files(
+                self.file_writer.partial_movie_directory, **kwargs
+            )
+        ]
+
+    @property
+    def _show_progress_bar(self) -> bool:
+        return True
+
+    @property
+    def _leave_progress_bar(self) -> bool:
+        return self.leave_progress_bars  # type: ignore
+
+    @property
+    def _start_at_animation_number(self) -> Optional[int]:
+        return self.start_at_animation_number  # type: ignore
+
+    def run(self, *args: Any, **kwargs: Any) -> None:
+        """MANIMGL renderer."""
+        super().run(*args, **kwargs)
+        self._save_slides(use_cache=False)
+
+
+class ThreeDSlide(Slide):
+    CONFIG: ClassVar[Dict[str, Any]] = {
+        "camera_class": ThreeDCamera,
+    }
+    pass

manim_slides/templates/revealjs.html

@@ -0,0 +1,332 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
+
+    <title>{{ title }}</title>
+
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/reveal.js/{{ reveal_version }}/reveal.min.css">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/reveal.js/{{ reveal_version }}/theme/{{ reveal_theme }}.min.css">
+
+    <!-- Theme used for syntax highlighting of code -->
+    <!-- <link rel="stylesheet" href="lib/css/zenburn.css"> -->
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.13.1/styles/zenburn.min.css">
+
+    <!-- <link rel="stylesheet" href="index.css"> -->
+  </head>
+
+  <body>
+    <div class="reveal">
+      <div class="slides">
+        {%- for presentation_config in presentation_configs -%}
+          {% set outer_loop = loop %}
+          {%- for slide_config in presentation_config.slides -%}
+            {%- if data_uri -%}
+              {% set file = file_to_data_uri(slide_config.file) %}
+            {%- else -%}
+              {% set file = assets_dir / slide_config.file.name %}
+            {%- endif -%}
+            <section
+              data-background-size={{ background_size }}
+              data-background-color="{{ presentation_config.background_color }}"
+              data-background-video="{{ file }}"
+              {% if loop.index == 1 and outer_loop.index == 1 -%}
+                data-background-video-muted
+              {%- endif -%}
+              {% if slide_config.loop -%}
+                data-background-video-loop
+              {%- endif -%}
+              {% if slide_config.auto_next -%}
+                data-autoslide="{{ get_duration_ms(slide_config.file) }}"
+              {%- endif -%}>
+            </section>
+          {%- endfor -%}
+        {%- endfor -%}
+      </div>
+    </div>
+
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/reveal.js/{{ reveal_version }}/reveal.min.js"></script>
+
+    <!-- To include plugins, see: https://revealjs.com/plugins/ -->
+
+    <!-- <script src="index.js"></script> -->
+    <script>
+      Reveal.initialize({
+        // The "normal" size of the presentation, aspect ratio will
+        // be preserved when the presentation is scaled to fit different
+        // resolutions. Can be specified using percentage units.
+        width: {{ width }},
+        height: {{ height }},
+
+        // Factor of the display size that should remain empty around
+        // the content
+        margin: {{ margin }},
+
+        // Bounds for smallest/largest possible scale to apply to content
+        minScale: {{ min_scale }},
+        maxScale: {{ max_scale }},
+
+        // Display presentation control arrows
+        controls: {{ controls }},
+
+        // Help the user learn the controls by providing hints, for example by
+        // bouncing the down arrow when they first encounter a vertical slide
+        controlsTutorial: {{ controls_tutorial }},
+
+        // Determines where controls appear, "edges" or "bottom-right"
+        controlsLayout: {{ controls_layout }},
+
+        // Visibility rule for backwards navigation arrows; "faded", "hidden"
+        // or "visible"
+        controlsBackArrows: {{ controls_back_arrows }},
+
+        // Display a presentation progress bar
+        progress: {{ progress }},
+
+        // Display the page number of the current slide
+        // - true:    Show slide number
+        // - false:   Hide slide number
+        //
+        // Can optionally be set as a string that specifies the number formatting:
+        // - "h.v":   Horizontal . vertical slide number (default)
+        // - "h/v":   Horizontal / vertical slide number
+        // - "c":   Flattened slide number
+        // - "c/t":   Flattened slide number / total slides
+        //
+        // Alternatively, you can provide a function that returns the slide
+        // number for the current slide. The function should take in a slide
+        // object and return an array with one string [slideNumber] or
+        // three strings [n1,delimiter,n2]. See #formatSlideNumber().
+        slideNumber: {{ slide_number }},
+
+        // Can be used to limit the contexts in which the slide number appears
+        // - "all":      Always show the slide number
+        // - "print":    Only when printing to PDF
+        // - "speaker":  Only in the speaker view
+        showSlideNumber: {{ show_slide_number }},
+
+        // Use 1 based indexing for # links to match slide number (default is zero
+        // based)
+        hashOneBasedIndex: {{ hash_one_based_index }},
+
+        // Add the current slide number to the URL hash so that reloading the
+        // page/copying the URL will return you to the same slide
+        hash: {{ hash }},
+
+        // Flags if we should monitor the hash and change slides accordingly
+        respondToHashChanges: {{ respond_to_hash_changes }},
+
+        // Push each slide change to the browser history.  Implies `hash: true`
+        history: {{ history }},
+
+        // Enable keyboard shortcuts for navigation
+        keyboard: {{ keyboard }},
+
+        // Optional function that blocks keyboard events when retuning false
+        //
+        // If you set this to 'focused', we will only capture keyboard events
+        // for embedded decks when they are in focus
+        keyboardCondition: {{ keyboard_condition }},
+
+        // Disables the default reveal.js slide layout (scaling and centering)
+        // so that you can use custom CSS layout
+        disableLayout: {{ disable_layout }},
+
+        // Enable the slide overview mode
+        overview: {{ overview }},
+
+        // Vertical centering of slides
+        center: {{ center }},
+
+        // Enables touch navigation on devices with touch input
+        touch: {{ touch }},
+
+        // Loop the presentation
+        loop: {{ loop }},
+
+        // Change the presentation direction to be RTL
+        rtl: {{ rtl }},
+
+        // Changes the behavior of our navigation directions.
+        //
+        // "default"
+        // Left/right arrow keys step between horizontal slides, up/down
+        // arrow keys step between vertical slides. Space key steps through
+        // all slides (both horizontal and vertical).
+        //
+        // "linear"
+        // Removes the up/down arrows. Left/right arrows step through all
+        // slides (both horizontal and vertical).
+        //
+        // "grid"
+        // When this is enabled, stepping left/right from a vertical stack
+        // to an adjacent vertical stack will land you at the same vertical
+        // index.
+        //
+        // Consider a deck with six slides ordered in two vertical stacks:
+        // 1.1    2.1
+        // 1.2    2.2
+        // 1.3    2.3
+        //
+        // If you're on slide 1.3 and navigate right, you will normally move
+        // from 1.3 -> 2.1. If "grid" is used, the same navigation takes you
+        // from 1.3 -> 2.3.
+        navigationMode: {{ navigation_mode }},
+
+        // Randomizes the order of slides each time the presentation loads
+        shuffle: {{ shuffle }},
+
+        // Turns fragments on and off globally
+        fragments: {{ fragments }},
+
+        // Flags whether to include the current fragment in the URL,
+        // so that reloading brings you to the same fragment position
+        fragmentInURL: {{ fragment_in_url }},
+
+        // Flags if the presentation is running in an embedded mode,
+        // i.e. contained within a limited portion of the screen
+        embedded: {{ embedded }},
+
+        // Flags if we should show a help overlay when the question-mark
+        // key is pressed
+        help: {{ help }},
+
+        // Flags if it should be possible to pause the presentation (blackout)
+        pause: {{ pause }},
+
+        // Flags if speaker notes should be visible to all viewers
+        showNotes: {{ show_notes }},
+
+        // Global override for autolaying embedded media (video/audio/iframe)
+        // - null:   Media will only autoplay if data-autoplay is present
+        // - true:   All media will autoplay, regardless of individual setting
+        // - false:  No media will autoplay, regardless of individual setting
+        autoPlayMedia: {{ auto_play_media }},
+
+        // Global override for preloading lazy-loaded iframes
+        // - null:   Iframes with data-src AND data-preload will be loaded when within
+        //           the viewDistance, iframes with only data-src will be loaded when visible
+        // - true:   All iframes with data-src will be loaded when within the viewDistance
+        // - false:  All iframes with data-src will be loaded only when visible
+        preloadIframes: {{ preload_iframes }},
+
+        // Can be used to globally disable auto-animation
+        autoAnimate: {{ auto_animate }},
+
+        // Optionally provide a custom element matcher that will be
+        // used to dictate which elements we can animate between.
+        autoAnimateMatcher: {{ auto_animate_matcher }},
+
+        // Default settings for our auto-animate transitions, can be
+        // overridden per-slide or per-element via data arguments
+        autoAnimateEasing: {{ auto_animate_easing }},
+        autoAnimateDuration: {{ auto_animate_duration }},
+        autoAnimateUnmatched: {{ auto_animate_unmatched }},
+
+        // CSS properties that can be auto-animated. Position & scale
+        // is matched separately so there's no need to include styles
+        // like top/right/bottom/left, width/height or margin.
+        autoAnimateStyles: {{ auto_animate_styles }},
+
+        // Controls automatic progression to the next slide
+        // - 0:      Auto-sliding only happens if the data-autoslide HTML attribute
+        //           is present on the current slide or fragment
+        // - 1+:     All slides will progress automatically at the given interval
+        // - false:  No auto-sliding, even if data-autoslide is present
+        autoSlide: {{ auto_slide }},
+
+        // Stop auto-sliding after user input
+        autoSlideStoppable: {{ auto_slide_stoppable }},
+
+        // Use this method for navigation when auto-sliding (defaults to navigateNext)
+        autoSlideMethod: {{ auto_slide_method }},
+
+        // Specify the average time in seconds that you think you will spend
+        // presenting each slide. This is used to show a pacing timer in the
+        // speaker view
+        defaultTiming: {{ default_timing }},
+
+        // Enable slide navigation via mouse wheel
+        mouseWheel: {{ mouse_wheel }},
+
+        // Opens links in an iframe preview overlay
+        // Add `data-preview-link` and `data-preview-link="false"` to customise each link
+        // individually
+        previewLinks: {{ preview_links }},
+
+        // Exposes the reveal.js API through window.postMessage
+        postMessage: {{ post_message }},
+
+        // Dispatches all reveal.js events to the parent window through postMessage
+        postMessageEvents: {{ post_message_events }},
+
+        // Focuses body when page changes visibility to ensure keyboard shortcuts work
+        focusBodyOnPageVisibilityChange: {{ focus_body_on_page_visibility_change }},
+
+        // Transition style
+        transition: {{ transition }}, // none/fade/slide/convex/concave/zoom
+
+        // Transition speed
+        transitionSpeed: {{ transition_speed }}, // default/fast/slow
+
+        // Transition style for full page slide backgrounds
+        backgroundTransition: {{ background_transition }}, // none/fade/slide/convex/concave/zoom
+
+        // The maximum number of pages a single slide can expand onto when printing
+        // to PDF, unlimited by default
+        pdfMaxPagesPerSlide: {{ pdf_max_pages_per_slide }},
+
+        // Prints each fragment on a separate slide
+        pdfSeparateFragments: {{ pdf_separate_fragments }},
+
+        // Offset used to reduce the height of content within exported PDF pages.
+        // This exists to account for environment differences based on how you
+        // print to PDF. CLI printing options, like phantomjs and wkpdf, can end
+        // on precisely the total height of the document whereas in-browser
+        // printing has to end one pixel before.
+        pdfPageHeightOffset: {{ pdf_page_height_offset }},
+
+        // Number of slides away from the current that are visible
+        viewDistance: {{ view_distance }},
+
+        // Number of slides away from the current that are visible on mobile
+        // devices. It is advisable to set this to a lower number than
+        // viewDistance in order to save resources.
+        mobileViewDistance: {{ mobile_view_distance }},
+
+        // The display mode that will be used to show slides
+        display: {{ display }},
+
+        // Hide cursor if inactive
+        hideInactiveCursor: {{ hide_inactive_cursor }},
+
+        // Time before the cursor is hidden (in ms)
+        hideCursorTime: {{ hide_cursor_time }}
+      });
+
+      {% if data_uri %}
+        // Fix found by @t-fritsch on GitHub
+        // see: https://github.com/hakimel/reveal.js/discussions/3362#discussioncomment-6651475.
+        function fixBase64VideoBackground(event) {
+          // event.previousSlide, event.currentSlide, event.indexh, event.indexv
+          if (event.currentSlide.getAttribute('data-background-video')) {
+            const background = Reveal.getSlideBackground(event.indexh, event.indexv),
+              video = background.querySelector('video'),
+              sources = video.querySelectorAll('source');
+
+            sources.forEach((source, i) => {
+              const src = source.getAttribute('src');
+              if(src.match(/^data:video.*;base64$/)) {
+                const nextSrc = sources[i+1]?.getAttribute('src');
+                video.setAttribute('src', `${src},${nextSrc}`);
+              }
+            });
+          }
+        }
+        Reveal.on( 'ready', fixBase64VideoBackground );
+        Reveal.on( 'slidechanged', fixBase64VideoBackground );
+      {% endif %}
+    </script>
+  </body>
+</html>

manim_slides/utils.py

@@ -0,0 +1,77 @@
+import hashlib
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import List
+
+from .logger import logger
+
+
+def concatenate_video_files(ffmpeg_bin: Path, files: List[Path], dest: Path) -> None:
+    """Concatenate multiple video files into one."""
+    f = tempfile.NamedTemporaryFile(mode="w", delete=False)
+    f.writelines(f"file '{path.absolute()}'\n" for path in files)
+    f.close()
+
+    command: List[str] = [
+        str(ffmpeg_bin),
+        "-f",
+        "concat",
+        "-safe",
+        "0",
+        "-i",
+        f.name,
+        "-c",
+        "copy",
+        str(dest),
+        "-y",
+    ]
+    logger.debug(" ".join(command))
+    process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    output, error = process.communicate()
+
+    if output:
+        logger.debug(output.decode())
+
+    if error:
+        logger.debug(error.decode())
+
+    if not dest.exists():
+        raise ValueError(
+            "could not properly concatenate files, use `-v DEBUG` for more details"
+        )
+
+
+def merge_basenames(files: List[Path]) -> Path:
+    """Merge multiple filenames by concatenating basenames."""
+    if len(files) == 0:
+        raise ValueError("Cannot merge an empty list of files!")
+
+    dirname: Path = files[0].parent
+    ext = files[0].suffix
+
+    basenames = list(file.stem for file in files)
+
+    basenames_str = ",".join(f"{len(b)}:{b}" for b in basenames)
+
+    # We use hashes to prevent too-long filenames, see issue #123:
+    # https://github.com/jeertmans/manim-slides/issues/123
+    basename = hashlib.sha256(basenames_str.encode()).hexdigest()
+
+    logger.debug(f"Generated a new basename for basenames: {basenames} -> '{basename}'")
+
+    return dirname.joinpath(basename + ext)
+
+
+def reverse_video_file(ffmpeg_bin: Path, src: Path, dst: Path) -> None:
+    """Reverses a video file, writting the result to `dst`."""
+    command = [str(ffmpeg_bin), "-y", "-i", str(src), "-vf", "reverse", str(dst)]
+    logger.debug(" ".join(command))
+    process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    output, error = process.communicate()
+
+    if output:
+        logger.debug(output.decode())
+
+    if error:
+        logger.debug(error.decode())

manim_slides/wizard.py

@@ -1,13 +1,12 @@
-import os
 import sys
 from functools import partial
+from pathlib import Path
 from typing import Any
 
 import click
 from PySide6.QtCore import Qt
 from PySide6.QtGui import QIcon, QKeyEvent
 from PySide6.QtWidgets import (
-    QApplication,
     QDialog,
     QDialogButtonBox,
     QGridLayout,
@@ -21,8 +20,9 @@ from PySide6.QtWidgets import (
 from .commons import config_options, verbosity_option
 from .config import Config, Key
 from .defaults import CONFIG_PATH
-from .manim import logger
-from .resources import *  # noqa: F401, F403
+from .logger import logger
+from .qt_utils import qapp
+from .resources import *  # noqa: F403
 
 WINDOW_NAME: str = "Configuration Wizard"
 
@@ -43,7 +43,7 @@ class KeyInput(QDialog):  # type: ignore
         self.layout.addWidget(self.label)
         self.setLayout(self.layout)
 
-    def keyPressEvent(self, event: QKeyEvent) -> None:
+    def keyPressEvent(self, event: QKeyEvent) -> None:  # noqa: N802
         self.key = event.key()
         self.deleteLater()
         event.accept()
@@ -57,22 +57,23 @@ class Wizard(QWidget):  # type: ignore
         self.config = config
         self.icon = QIcon(":/icon.png")
         self.setWindowIcon(self.icon)
+        self.closed_without_saving = False
 
-        QBtn = QDialogButtonBox.Save | QDialogButtonBox.Cancel
+        button = QDialogButtonBox.Save | QDialogButtonBox.Cancel
 
-        self.buttonBox = QDialogButtonBox(QBtn)
-        self.buttonBox.accepted.connect(self.saveConfig)
-        self.buttonBox.rejected.connect(self.closeWithoutSaving)
+        self.button_box = QDialogButtonBox(button)
+        self.button_box.accepted.connect(self.save_config)
+        self.button_box.rejected.connect(self.close_without_saving)
 
         self.buttons = []
 
         self.layout = QGridLayout()
 
-        for i, (key, value) in enumerate(self.config.dict().items()):
+        for i, (key, value) in enumerate(self.config.keys.dict().items()):
             # Create label for key name information
             label = QLabel()
             key_info = value["name"] or key
-            label.setText(key_info)
+            label.setText(key_info.title())
             self.layout.addWidget(label, i, 0)
 
             # Create button that will pop-up a dialog and ask to input a new key
@@ -83,26 +84,26 @@ class Wizard(QWidget):  # type: ignore
             )
             self.buttons.append(button)
             button.clicked.connect(
-                partial(self.openDialog, i, getattr(self.config, key))
+                partial(self.open_dialog, i, getattr(self.config.keys, key))
             )
             self.layout.addWidget(button, i, 1)
 
-        self.layout.addWidget(self.buttonBox, len(self.buttons), 1)
+        self.layout.addWidget(self.button_box, len(self.buttons), 1)
 
         self.setLayout(self.layout)
 
-    def closeWithoutSaving(self) -> None:
+    def close_without_saving(self) -> None:
         logger.debug("Closing configuration wizard without saving")
+        self.closed_without_saving = True
         self.deleteLater()
-        sys.exit(0)
 
-    def closeEvent(self, event: Any) -> None:
-        self.closeWithoutSaving()
+    def closeEvent(self, event: Any) -> None:  # noqa: N802
+        self.close_without_saving()
         event.accept()
 
-    def saveConfig(self) -> None:
+    def save_config(self) -> None:
         try:
-            Config.parse_obj(self.config.dict())
+            Config.model_validate(self.config.dict())
         except ValueError:
             msg = QMessageBox()
             msg.setIcon(QMessageBox.Critical)
@@ -111,15 +112,15 @@ class Wizard(QWidget):  # type: ignore
                 "Two or more actions share a common key: make sure actions have distinct key codes."
             )
             msg.setWindowTitle("Error: duplicated keys")
-            msg.exec_()
+            msg.exec()
             return
 
         self.deleteLater()
 
-    def openDialog(self, button_number: int, key: Key) -> None:
+    def open_dialog(self, button_number: int, key: Key) -> None:
         button = self.buttons[button_number]
         dialog = KeyInput()
-        dialog.exec_()
+        dialog.exec()
         if dialog.key is not None:
             key_name = keymap[dialog.key]
             key.set_ids(dialog.key)
@@ -130,7 +131,7 @@ class Wizard(QWidget):  # type: ignore
 @config_options
 @click.help_option("-h", "--help")
 @verbosity_option
-def wizard(config_path: str, force: bool, merge: bool) -> None:
+def wizard(config_path: Path, force: bool, merge: bool) -> None:
     """Launch configuration wizard."""
     return _init(config_path, force, merge, skip_interactive=False)
 
@@ -140,18 +141,20 @@ def wizard(config_path: str, force: bool, merge: bool) -> None:
 @click.help_option("-h", "--help")
 @verbosity_option
 def init(
-    config_path: str, force: bool, merge: bool, skip_interactive: bool = False
+    config_path: Path, force: bool, merge: bool, skip_interactive: bool = False
 ) -> None:
     """Initialize a new default configuration file."""
     return _init(config_path, force, merge, skip_interactive=True)
 
 
 def _init(
-    config_path: str, force: bool, merge: bool, skip_interactive: bool = False
+    config_path: Path, force: bool, merge: bool, skip_interactive: bool = False
 ) -> None:
-    """Actual initialization code for configuration file, with optional interactive mode."""
-
-    if os.path.exists(config_path):
+    """
+    Actual initialization code for configuration file, with optional interactive
+    mode.
+    """
+    if config_path.exists():
         click.secho(f"The `{CONFIG_PATH}` configuration file exists")
 
         if not force and not merge:
@@ -175,21 +178,23 @@ def _init(
         logger.debug("Merging new config into `{config_path}`")
 
     if not skip_interactive:
-        if os.path.exists(config_path):
-            config = Config.parse_file(config_path)
+        if config_path.exists():
+            config = Config.from_file(config_path)
 
-        app = QApplication(sys.argv)
+        app = qapp()
         app.setApplicationName("Manim Slides Wizard")
         window = Wizard(config)
         window.show()
         app.exec()
 
+        if window.closed_without_saving:
+            sys.exit(0)
+
         config = window.config
 
     if merge:
-        config = Config.parse_file(config_path).merge_with(config)
+        config = Config.from_file(config_path).merge_with(config)
 
-    with open(config_path, "w") as config_file:
-        config_file.write(config.json(indent=2))
+    config.to_file(config_path)
 
     click.secho(f"Configuration file successfully saved to `{config_path}`")

paper/paper.bib

@@ -0,0 +1,53 @@
+@online{manim-announcement,
+  author = {Grant Sanderson},
+  title = {{Q}\&{A} with {G}rant {S}anderson (3blue1brown)},
+  year = {2018},
+  organization = {YouTube},
+  url = {https://www.youtube.com/watch?v=Qe6o9j4IjTo\&ab_channel=3Blue1Brown}
+}
+
+@misc{revealjs,
+  author = {Hakim El Hattab},
+  title = {The HTML Presentation Framework},
+  year = {2022},
+  publisher = {GitHub},
+  journal = {GitHub repository},
+  url = {https://github.com/hakimel/reveal.js}
+}
+
+@misc{manim-presentation,
+  author = {Federico Galatolo},
+  title = {Tool for live presentations using manim},
+  year = {2021},
+  publisher = {GitHub},
+  journal = {GitHub repository},
+  url = {https://github.com/galatolofederico/manim-presentation}
+}
+
+@misc{manimgl,
+  author = {Grant Sanderson},
+  title = {Animation engine for explanatory math videos},
+  year = {2022},
+  publisher = {GitHub},
+  journal = {GitHub repository},
+  url = {https://github.com/3b1b/manim}
+}
+
+@misc{manim-editor,
+  author = {Christopher Besch},
+  title = {Web Presenter for Mathematical Animations using Manim},
+  year = {2022},
+  publisher = {GitHub},
+  journal = {GitHub repository},
+  url = {https://github.com/ManimCommunity/manim_editor}
+}
+
+@software{manimce,
+  author = {{The Manim Community Developers}},
+  license = {MIT},
+  month = {12},
+  title = {{Manim – Mathematical Animation Framework}},
+  url = {https://www.manim.community/},
+  version = {v0.17.2},
+  year = {2022}
+}

paper/paper.md

@@ -0,0 +1,174 @@
+---
+title: 'Manim Slides: A Python package for presenting Manim content anywhere'
+tags:
+  - Python
+  - manim
+  - animations
+  - teaching
+  - conference presentations
+  - tool
+authors:
+  - name: Jérome Eertmans
+    orcid: 0000-0002-5579-5360
+    affiliation: 1
+affiliations:
+ - name: ICTEAM, UCLouvain, Belgium
+   index: 1
+date: 2 March 2023
+bibliography: paper.bib
+---
+
+# Summary
+
+Manim Slides is a Python package that makes presenting Manim animations
+straightforward. With minimal changes required to pre-existing code, one can
+slide through animations in a *PowerPoint-like* manner, or share its slides
+*online* using ReavealJS' power.
+
+# Introduction
+
+Presenting educational content has always been a difficult task, especially
+when it uses temporal or iterative concepts. During the last decades, the
+presence of computers in classrooms for educational purposes has increased
+enormously, allowing teachers to show animated or interactive content.
+
+With the democratization of YouTube, many people have decided to use this
+platform to share educational content. Among these people, Grant Sanderson, a
+YouTuber presenting videos on the theme of mathematics, quickly became known
+for his original and quality animations. In 2018, Grant announced in a video
+that he creates his animations using a self-developed Python tool called Manim
+[@manim-announcement]. In 2019, he made the Manim source code public [@manimgl],
+so anyone can use his tool. Very quickly, the community came together and, in
+2020, created a "fork" of the original GitHub repository [@manimce], in order to
+create a more accessible and better documented version of this tool. Since then,
+the two versions are differentiated by using ManimGL for Grant Sanderson's
+version, as it uses OpenGL for rendering, and ManimCE for the community edition
+(CE).
+
+Despite the many advantages of the Manim tool in terms of illustrating
+mathematical concepts, one cannot help but notice that most presentations,
+whether in the classroom or at a conference, are mainly done with PowerPoint
+or PDF slides. One of the many advantages of these formats, as opposed to videos
+created with Manim, is the ability to pause, rewind, etc., whenever you want.
+
+To face this problem, in 2021, the manim-presentation tool was created
+[@manim-presentation]. This tool allows you to present Manim animations as you
+would present slides: with pauses, slide jumps, etc. However, this tool has
+evolved very little since its inception and does not work with ManimGL.
+
+In 2022, Manim Slides has been created from manim-presentation, with the aim
+to make it a more complete tool, better documented, and usable on all platforms
+and with ManimCE or ManimGL. After almost a year of existence, Manim Slides has
+evolved a lot (see
+[comparison section](#comparison-with-manim-presentation)),
+has built a small community of contributors, and continues to
+provide new features on a regular basis.
+
+# Easy to Use Commitment
+
+Manim Slides is commited to be an easy-to-use tool, with minimal installation
+procedure and few modifications required. It can either be used locally with its
+graphical user interface (GUI), or shared via one of the two formats it can
+convert to:
+
+* an HTML page thanks to the RevealJS Javascript package [@revealjs];
+* or a PowerPoint (`.pptx`) file.
+
+This work has a very similar syntax to Manim and offers a comprehensive
+documentation hosted on [GitHub pages](https://jeertmans.github.io/manim-slides/), see
+\autoref{fig:docs}.
+
+![Manim Slides' documentation homepage.\label{fig:docs}](docs.png)
+
+# Example usage
+
+We have used manim-presentation for our presentation at the COST
+Interact, hosted in Lyon, 2022, and
+[available online](https://web.archive.org/web/20230507184944/https://eertmans.be/posts/cost-interact-presentation/).
+This experience highly motivated the development of Manim Slides, and our
+EuCAP 2023 presentation slides are already
+[available online](https://web.archive.org/web/20230507211243/https://eertmans.be/posts/eucap-presentation/), thanks
+to Manim Slides' HTML feature.
+
+Also, one of our users created a short
+[video tutorial](https://www.youtube.com/watch?v=Oc9g89VzKsY&ab_channel=TheoremofBeethoven)
+and posted it on YouTube.
+
+# Stability and releases
+
+Manim Slides is continously tested on most recent Python versions, both ManimCE
+and ManimGL, and on all major platforms: **Ubuntu**, **macOS** and **Windows**. Due to Manim
+Slide's exposed API being very minimal, and the variety of tests that are
+performed, this tool can be considered stable over time.
+
+New releases are very frequent, as they mostly introduce enhancements or small
+documention fixes, and the command-line tool automatically notifies for new
+available updates. Therefore, regularly updating Manim Slides is highly
+recommended.
+
+# Statement of Need
+
+Similar tools to Manim Slides also exist, such as its predecessor,
+manim-presentation [@manim-presentation], or the web-based alternative, Manim
+Editor [@manim-editor], but none of them provide the documentation level nor the
+amount of features that Manim Slides strives to. This work makes the task of
+presenting Manim content in front of an audience much easier than before,
+allowing presenters to focus more on the content of their slides, rather than on
+how to actually present them efficiently.
+
+## Target Audience
+
+Manim Slides was developed with the goal of making educational content more
+accessible than ever. We believe that researchers, professors, teaching
+assistants and anyone else who needs to teach scientific content can benefit
+from using this tool. The ability to pace your presentation yourself is
+essential, and Manim Slides gives you that ability.
+
+## A Need for Portability
+
+One of the major concerns with presenting content in a non-standard format
+(i.e., not just a plain PDF) is the issue of portability.
+Depending on the programs available, the power of the target computer,
+or the access to the internet, not all solutions are equal.
+From the same configuration file, Manim Slides offers a series of solutions to
+share your slides, which we discuss on our
+[Sharing your slides](https://jeertmans.github.io/manim-slides/reference/sharing.html)
+page.
+
+## Comparison with manim-presentation
+
+Starting from @manim-presentation's original work, Manim Slides now provides
+numerous additional features.
+A non-exhaustive list of those new features is as follows:
+
+* ManimGL compatibility;
+* playing slides in reverse;
+* exporting slides to HTML and PowerPoint;
+* 3D scene support;
+* multiple key inputs can map to the same action
+  (e.g., useful when using a pointer);
+* optionally hiding mouse cursor when presenting;
+* recording your presentation;
+* multiple video scaling methods (for speed-vs-quality tradeoff);
+* and automatic detection of some scene parameters
+  (e.g., resolution or background color).
+
+The complete and up-to-date set of features Manim Slide supports is
+available in the
+[online documentation](https://jeertmans.github.io/manim-slides/).
+For new feature requests, we highly encourage users to
+[create an issue](https://github.com/jeertmans/manim-slides/issues/new/choose)
+with the appropriate template.
+
+# Acknowledgements
+
+We acknowledge the work of @manim-presentation that paved the initial structure
+of Manim Slides with the manim-presentation Python package.
+
+We also acknowledge Grant Sanderson for his tremendous work on Manim, as
+well as the Manim Community contributors.
+
+Finally, we also acknowledge contributions from the GitHub contributors on the
+Manim Slides repository.
+
+# References

pyproject.toml

@@ -5,33 +5,11 @@ requires = ["setuptools", "poetry-core>=1.0.0"]
 [tool.black]
 target-version = ["py38"]
 
-[tool.isort]
-profile = "black"
-py_version = 38
-
 [tool.mypy]
-check-untyped-defs = true
-# Disallow dynamic typing
-disallow-any-generics = true
-disallow-incomplete-defs = true
-disallow-subclassing-any = true
-# Disallow untyped definitions and calls
-disallow-untyped-defs = true
-ignore-missing-imports = true
-install-types = true
-# None and optional handling
-no-implicit-optional = true
-no-warn-return-any = true
-non-interactive = true
+disallow_untyped_decorators = false
+install_types = true
 python_version = "3.8"
-# Strict equality
-strict-equality = true
-warn-no-return = true
-warn-redundant-casts = true
-# Config file
-warn-unused-configs = true
-# Configuring warnings
-warn-unused-ignores = true
+strict = true
 
 [tool.poetry]
 authors = [
@@ -61,19 +39,39 @@ packages = [
 ]
 readme = "README.md"
 repository = "https://github.com/jeertmans/manim-slides"
-version = "4.9.2"
+version = "5.0.0"
 
 [tool.poetry.dependencies]
 click = "^8.1.3"
 click-default-group = "^1.2.2"
+docutils = {version = "^0.20.1", optional = true}
+ipython = {version = ">=8.12.2", optional = true}
+jinja2 = "^3.1.2"
+lxml = "^4.9.2"
+manim = {version = "^0.17.3", optional = true}
+manimgl = {version = "^1.6.1", optional = true}
 numpy = "^1.19"
 opencv-python = "^4.6.0.66"
-pydantic = "^1.10.2"
-pyside6 = "^6.4.1"
+pillow = "^9.5.0"
+pydantic = "^2.0.1"
+pydantic-extra-types = "^2.0.0"
+pyside6 = "6.5.2"
 python = ">=3.8.1,<3.12"
+python-pptx = "^0.6.21"
 requests = "^2.28.1"
+rich = "^13.3.2"
+rtoml = "^0.9.0"
 tqdm = "^4.64.1"
 
+[tool.poetry.extras]
+magic = ["manim", "ipython"]
+manim = ["manim"]
+manimgl = ["manimgl"]
+sphinx-directive = ["docutils", "manim"]
+
+[tool.poetry.group.dev]
+optional = true
+
 [tool.poetry.group.dev.dependencies]
 black = "^22.10.0"
 bump2version = "^1.0.1"
@@ -82,26 +80,64 @@ mypy = "^0.991"
 pre-commit = "^3.0.2"
 ruff = "^0.0.219"
 
+[tool.poetry.group.docs]
+optional = true
+
 [tool.poetry.group.docs.dependencies]
-furo = "^2022.9.29"
-manim = "^0.17.0"
-myst-parser = "^0.18.1"
-sphinx = "^5.3.0"
+furo = "^2023.5.20"
+ipykernel = "^6.25.1"
+manim = "^0.17.3"
+myst-parser = "^2.0.0"
+nbsphinx = "^0.9.2"
+pandoc = "^2.3"
+sphinx = "^7.0.1"
 sphinx-click = "^4.4.0"
 sphinx-copybutton = "^0.5.1"
 sphinxext-opengraph = "^0.7.5"
 
+[tool.poetry.group.test]
+optional = true
+
 [tool.poetry.group.test.dependencies]
-manim = "^0.17.0"
+manim = "^0.17.3"
 manimgl = "^1.6.1"
+pytest = "^7.4.0"
+pytest-cov = "^4.1.0"
+pytest-env = "^0.8.2"
+pytest-qt = "^4.2.0"
+pytest-xdist = "^3.3.1"
 
 [tool.poetry.plugins]
 
 [tool.poetry.plugins."console_scripts"]
 manim-slides = "manim_slides.__main__:cli"
 
+[tool.pytest.ini_options]
+env = [
+  "QT_QPA_PLATFORM=offscreen"
+]
+filterwarnings = [
+  "error",
+  "ignore::DeprecationWarning"
+]
+
 [tool.ruff]
-ignore = [
+extend-exclude = ["manim_slides/resources.py"]
+extend-ignore = [
+  "D100",
+  "D101",
+  "D102",
+  "D103",
+  "D104",
+  "D105",
+  "D106",
+  "D107",
+  "D203",
+  "D205",
+  "D212",
   "E501"
 ]
+extend-select = ["B", "C90", "D", "I", "N", "RUF", "UP", "T"]
+isort = {known-first-party = ['manim_slides', 'tests']}
+line-length = 88
 target-version = "py38"

static/logo.py

@@ -1,17 +1,29 @@
 # flake8: noqa: F403, F405
 # type: ignore
+import os
+
 from manim import *
 
+THEME = os.environ.get("MANIM_SLIDES_THEME", "light").lower().replace("_", "-")
+
 
 class ManimSlidesLogo(Scene):
     def construct(self):
         tex_template = TexTemplate()
         tex_template.add_to_preamble(r"\usepackage{graphicx}\usepackage{fontawesome5}")
-        self.camera.background_color = "#ffffff"
+        self.camera.background_color = {
+            "light": "#ffffff",
+            "dark-docs": "#131416",
+            "dark-github": "#0d1117",
+        }[THEME]
         logo_green = "#87c2a5"
         logo_blue = "#525893"
         logo_red = "#e07a5f"
-        logo_black = "#343434"
+        logo_black = {
+            "light": "#343434",
+            "dark-docs": "#d0d0d0",
+            "dark-github": "#c9d1d9",
+        }[THEME]
         ds_m = MathTex(r"\mathbb{M}", fill_color=logo_black).scale(7)
         ds_m.shift(2.25 * LEFT + 1.5 * UP)
         slides = MathTex(r"\mathbb{S}\text{lides}", fill_color=logo_black).scale(4)

static/make_logo.sh

@@ -0,0 +1,21 @@
+#! /bin/bash
+
+MANIM_SLIDES_THEME=light poetry run manim render -qk -s --format png --resolution 2560,1280 static/logo.py && mv media/images/logo/*.png static/logo.png
+
+ln -f -r -s static/logo.png docs/source/_static/logo.png
+
+MANIM_SLIDES_THEME=dark_docs poetry run manim render -qk -s --format png --resolution 2560,1280 static/logo.py && mv media/images/logo/*.png static/logo_dark_docs.png
+
+ln -f -r -s static/logo_dark_docs.png docs/source/_static/logo_dark_docs.png
+
+MANIM_SLIDES_THEME=dark_github poetry run manim render -qk -s --format png --resolution 2560,1280 static/logo.py && mv media/images/logo/*.png static/logo_dark_github.png
+
+ln -f -r -s static/logo_dark_github.png docs/source/_static/logo_dark_github.png
+
+MANIM_SLIDES_THEME=light poetry run manim render -t -qk -s --format png --resolution 2560,1280 static/logo.py && mv media/images/logo/*.png static/logo_light_transparent.png
+
+ln -f -r -s static/logo_light_transparent.png docs/source/_static/logo_light_transparent.png
+
+MANIM_SLIDES_THEME=dark_docs poetry run manim render -t -qk -s --format png --resolution 2560,1280 static/logo.py && mv media/images/logo/*.png static/logo_dark_transparent.png
+
+ln -f -r -s static/logo_dark_transparent.png docs/source/_static/logo_dark_transparent.png

tests/conftest.py

@@ -0,0 +1,78 @@
+import random
+import string
+from pathlib import Path
+from typing import Generator, Iterator, List
+
+import pytest
+
+from manim_slides.config import PresentationConfig
+
+
+@pytest.fixture(scope="session")
+def tests_folder() -> Iterator[Path]:
+    yield Path(__file__).parent.resolve(strict=True)
+
+
+@pytest.fixture(scope="session")
+def project_folder(tests_folder: Path) -> Iterator[Path]:
+    yield tests_folder.parent.resolve(strict=True)
+
+
+@pytest.fixture(scope="session")
+def data_folder(tests_folder: Path) -> Iterator[Path]:
+    yield (tests_folder / "data").resolve(strict=True)
+
+
+@pytest.fixture(scope="session")
+def slides_folder(data_folder: Path) -> Iterator[Path]:
+    yield (data_folder / "slides").resolve(strict=True)
+
+
+@pytest.fixture(scope="session")
+def slides_file(data_folder: Path) -> Iterator[Path]:
+    yield (data_folder / "slides.py").resolve(strict=True)
+
+
+@pytest.fixture(scope="session")
+def manimgl_config(project_folder: Path) -> Iterator[Path]:
+    yield (project_folder / "custom_config.yml").resolve(strict=True)
+
+
+@pytest.fixture(scope="session")
+def video_file(data_folder: Path) -> Iterator[Path]:
+    yield (data_folder / "video.mp4").resolve(strict=True)
+
+
+@pytest.fixture(scope="session")
+def video_data_uri_file(data_folder: Path) -> Iterator[Path]:
+    yield (data_folder / "video_data_uri.txt").resolve(strict=True)
+
+
+def random_path(
+    length: int = 20,
+    dirname: Path = Path("./media/videos/example"),
+    suffix: str = ".mp4",
+    touch: bool = False,
+) -> Path:
+    basename = "".join(random.choices(string.ascii_letters, k=length))
+
+    filepath = dirname.joinpath(basename + suffix)
+
+    if touch:
+        filepath.touch()
+
+    return filepath.resolve(strict=touch)
+
+
+@pytest.fixture
+def paths() -> Generator[List[Path], None, None]:
+    random.seed(1234)
+
+    yield [random_path() for _ in range(20)]
+
+
+@pytest.fixture(scope="session")
+def presentation_config(
+    slides_folder: Path,
+) -> Generator[PresentationConfig, None, None]:
+    yield PresentationConfig.from_file(slides_folder / "BasicSlide.json")

tests/data/slides.py

@@ -0,0 +1,40 @@
+# flake8: noqa: F403, F405
+# type: ignore
+
+from manim_slides import Slide
+from manim_slides.slide import MANIM, MANIMGL
+
+if MANIM:
+    from manim import *
+elif MANIMGL:
+    from manimlib import *
+
+
+class BasicSlide(Slide):
+    def construct(self):
+        text = Text("This is some text")
+
+        self.play(Write(text))
+
+        circle = Circle(radius=3, color=BLUE)
+
+        self.play(Transform(text, circle))
+
+        circle = text  # this is to avoid name confusion
+
+        square = Square()
+
+        self.play(FadeIn(square))
+
+        self.next_slide(loop=True)
+
+        self.play(Rotate(square, +PI / 2))
+        self.play(Rotate(square, -PI / 2))
+
+        self.next_slide()
+
+        other_text = Text("Other text")
+        self.wipe([square, circle], [other_text])
+
+        self.next_slide()
+        self.zoom(other_text, [])

tests/data/slides/BasicSlide.json

@@ -0,0 +1,29 @@
+{
+  "slides": [
+    {
+      "file": "slides/files/BasicSlide/28bf32c4df2711b07b765a647667059683133b3c45291f34692be0c845f75511.mp4",
+      "rev_file": "slides/files/BasicSlide/28bf32c4df2711b07b765a647667059683133b3c45291f34692be0c845f75511_reversed.mp4",
+      "loop": false
+    },
+    {
+      "file": "slides/files/BasicSlide/c7d0d9ccbf764d32bf316451f2d00607b8f12893e64afe215041a8aedceeb368.mp4",
+      "rev_file": "slides/files/BasicSlide/c7d0d9ccbf764d32bf316451f2d00607b8f12893e64afe215041a8aedceeb368_reversed.mp4",
+      "loop": true
+    },
+    {
+      "file": "slides/files/BasicSlide/5060f74bee3cb2e40a399a023e0120b3f91d348a9867c7f401db54ea337de97c.mp4",
+      "rev_file": "slides/files/BasicSlide/5060f74bee3cb2e40a399a023e0120b3f91d348a9867c7f401db54ea337de97c_reversed.mp4",
+      "loop": false
+    },
+    {
+      "file": "slides/files/BasicSlide/7a5de547a0b5de2230ff3451dd680425cf0a7ea065b31e8f92b5e93527694077.mp4",
+      "rev_file": "slides/files/BasicSlide/7a5de547a0b5de2230ff3451dd680425cf0a7ea065b31e8f92b5e93527694077_reversed.mp4",
+      "loop": false
+    }
+  ],
+  "resolution": [
+    854,
+    480
+  ],
+  "background_color": "black"
+}