burns 0.0.0__tar.gz

burns-0.0.0/.gitattributes

@@ -0,0 +1 @@
+*.ipynb linguist-documentation

burns-0.0.0/.github/workflows/ci.yml

@@ -0,0 +1,48 @@
+# wads CI — calls the reusable workflow hosted in i2mint/wads.
+#
+# All configuration comes from this repo's pyproject.toml [tool.wads.ci.*].
+# To customize the workflow itself (rare), replace this file with the
+# full inline template `wads/data/github_ci_uv.yml` from i2mint/wads.
+#
+# Pinning: `@master` floats with wads. If you need version stability for
+# a release-sensitive repo, change `@master` to a wads tag (e.g. `@v0.1.81`).
+# CI failure does not block a published release — it blocks the publish
+# step itself — so floating master is generally safe.
+#
+# Permissions: GitHub validates that the caller grants AT LEAST the
+# permissions any job in the called workflow requests — at workflow-parse
+# time, not at run-time, even if the job would be skipped via `if:`.
+# The reusable workflow needs:
+#   contents: write   for the publish job's version-bump push-back
+#                     and for the github-pages job's gh-pages branch push
+#   pages: write      for the github-pages job's REST API Pages config
+# Both default to `write` on org-account GITHUB_TOKEN and need to be
+# granted explicitly on personal-account callers (where the default is
+# read-only). No `id-token: write` needed — the publish-github-pages
+# action uses peaceiris/actions-gh-pages (branch-based) + REST API,
+# not the OIDC `actions/deploy-pages` flow.
+name: Continuous Integration
+on: [push, pull_request]
+jobs:
+  ci:
+    uses: i2mint/wads/.github/workflows/uv-ci.yml@master
+    permissions:
+      contents: write
+      pages: write
+    # Explicit pass-through (not `secrets: inherit`) because `inherit` does
+    # not reliably propagate caller-repo secrets to a reusable workflow
+    # owned by a different account (verified empirically: caller in a
+    # personal account, called in i2mint org → `${{ secrets.PYPI_PASSWORD }}`
+    # resolved to empty inside the reusable workflow despite the secret
+    # being set on the caller repo). Listing each secret here makes the
+    # propagation unambiguous regardless of caller-vs-called ownership.
+    # Missing secrets on the caller resolve to empty strings, harmless for
+    # the optional ones; PYPI_PASSWORD must be set for the publish job.
+    secrets:
+      PYPI_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
+      OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+      ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+      HF_TOKEN: ${{ secrets.HF_TOKEN }}
+      HUGGINGFACE_TOKEN: ${{ secrets.HUGGINGFACE_TOKEN }}
+      KAGGLE_USERNAME: ${{ secrets.KAGGLE_USERNAME }}
+      KAGGLE_KEY: ${{ secrets.KAGGLE_KEY }}

burns-0.0.0/.gitignore

@@ -0,0 +1,120 @@
+.claude/handoffs/
+.claude/scratch/
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+
+.DS_Store
+# C extensions
+*.so
+
+# TLS certificates
+## Ignore all PEM files anywhere
+*.pem
+## Also ignore any certs directory
+certs/
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+_build
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+docs/*
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+
+# PyCharm
+.idea

burns-0.0.0/LICENSE

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

burns-0.0.0/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: burns
+Version: 0.0.0
+Summary: Ken Burns pan/zoom video effects: turn a still image (or a sequence of stills) into a cinematic pan/zoom film.
+Project-URL: Homepage, https://github.com/thorwhalen/burns
+Project-URL: Repository, https://github.com/thorwhalen/burns
+Project-URL: Documentation, https://thorwhalen.github.io/burns
+Author: Thor Whalen
+License: mit
+License-File: LICENSE
+Keywords: animation,ken-burns,moviepy,pan-zoom,slideshow,video
+Requires-Python: >=3.10
+Requires-Dist: moviepy
+Requires-Dist: numpy
+Requires-Dist: pillow
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: sphinx-rtd-theme>=1.0; extra == 'docs'
+Requires-Dist: sphinx>=6.0; extra == 'docs'
+Description-Content-Type: text/markdown
+
+# burns
+
+Ken Burns pan/zoom video effects: turn a still image — or a sequence of stills —
+into a cinematic pan/zoom film.
+
+The [Ken Burns effect](https://en.wikipedia.org/wiki/Ken_Burns_effect) animates a
+static photograph by slowly panning across it and zooming in or out, giving still
+images a sense of motion. `burns` does exactly that, with a tiny API and no
+configuration required.
+
+```bash
+pip install burns
+```
+
+`burns` needs `ffmpeg` available on your system (moviepy uses it to encode video).
+On macOS: `brew install ffmpeg`. On Debian/Ubuntu: `sudo apt-get install ffmpeg`.
+
+## Quickstart
+
+A standard 2-second push-in, written next to the source image:
+
+```python
+from burns import ken_burns_video
+
+ken_burns_video("photo.jpg")          # → photo_kenburns.mp4
+```
+
+That's it. The result is an mp4 that slowly zooms into the center of `photo.jpg`.
+
+## A little more control
+
+The camera path is a list of **phases**, each `(start_rect, end_rect, duration_s)`.
+A *rect* is `(cx, cy, s)` — a pan center `(cx, cy)` in `[0, 1]` image units and a
+zoom scale `s` (`1.0` = the full frame, `> 1.0` = zoomed in). The camera moves
+linearly from `start_rect` to `end_rect` over `duration_s` seconds; phases play
+back-to-back.
+
+```python
+from burns import ken_burns_video
+
+# Pan from the full frame toward the upper-right while zooming in, over 5s.
+ken_burns_video(
+    "photo.jpg",
+    phases=[((0.5, 0.5, 1.0), (0.65, 0.40, 1.2), 5.0)],
+    saveas="out.mp4",
+)
+
+# A three-phase move: zoom in, pan across, settle back to center.
+ken_burns_video(
+    "photo.jpg",
+    phases=[
+        ((0.5, 0.5, 1.0), (0.65, 0.40, 1.2), 4.0),
+        ((0.65, 0.40, 1.2), (0.35, 0.60, 1.2), 4.0),
+        ((0.35, 0.60, 1.2), (0.5, 0.5, 1.3), 4.0),
+    ],
+)
+```
+
+Rects accept flexible shorthand: a bare number is a centered zoom (`1.3`), a pair
+is a pan center at full scale (`(0.3, 0.7)`), a triple is the full spec.
+
+## Let `burns` design the motion for you
+
+Hand-authoring rectangles for every image gets tedious. `ken_burns_path` generates
+a cohesive, **deterministic, non-repetitive** path from a few intent parameters —
+pass the image's position (`index`) and a duration, and it picks the framing:
+
+```python
+from burns import ken_burns_video, ken_burns_path
+
+# index seeds the focal direction; odd indices push in, even pull out.
+ken_burns_video("photo.jpg", phases=ken_burns_path(1, 5.0))
+
+# styles: "push" (zoom-led, the default) or "drift" (pure horizontal pan)
+ken_burns_video("photo.jpg", phases=ken_burns_path(2, 5.0, style="drift"))
+
+# ease=True replaces constant velocity with a slow-fast-slow curve
+ken_burns_video("photo.jpg", phases=ken_burns_path(1, 6.0, ease=True))
+```
+
+## Multi-image films
+
+`ken_burns_film` renders a sequence of `(image, phases)` panels as **one
+continuous film** — a single encode pass, so there are no concatenation seams and
+no per-image freeze frames at the cuts. Pass an optional pre-built audio track to
+mux it in.
+
+```python
+from burns import ken_burns_film, ken_burns_path
+
+panels = [
+    ("a.jpg", ken_burns_path(1, 4.0)),
+    ("b.jpg", ken_burns_path(2, 4.0)),
+    ("c.jpg", ken_burns_path(3, 4.0)),
+]
+ken_burns_film(panels, saveas="film.mp4", fps=30, audio_path="narration.mp3")
+```
+
+## API
+
+| Function | What it does |
+|----------|--------------|
+| `ken_burns_video(image, *, phases=..., fps=30, saveas=None, ...)` | Render one image into a multi-phase pan/zoom mp4. Accepts a path, a `PIL.Image`, or a numpy array. |
+| `ken_burns_film(panels, *, saveas, fps=30, audio_path=None, ...)` | Render a sequence of `(image, phases)` panels as one continuous film, with optional audio. |
+| `ken_burns_path(index, duration_s, *, style="push", zoom=1.10, pan=0.03, ease=False)` | Generate a deterministic pan/zoom path (the `phases` the renderers consume). |
+
+All rectangles are `(cx, cy, s)` — pan center in `[0, 1]`, zoom scale (`1.0` = full
+frame). Because the crop box is clamped to the image, you cannot zoom out past the
+original; express a zoom-out as a start `s > 1` panning to an end `s = 1`.

burns-0.0.0/README.md

@@ -0,0 +1,109 @@
+# burns
+
+Ken Burns pan/zoom video effects: turn a still image — or a sequence of stills —
+into a cinematic pan/zoom film.
+
+The [Ken Burns effect](https://en.wikipedia.org/wiki/Ken_Burns_effect) animates a
+static photograph by slowly panning across it and zooming in or out, giving still
+images a sense of motion. `burns` does exactly that, with a tiny API and no
+configuration required.
+
+```bash
+pip install burns
+```
+
+`burns` needs `ffmpeg` available on your system (moviepy uses it to encode video).
+On macOS: `brew install ffmpeg`. On Debian/Ubuntu: `sudo apt-get install ffmpeg`.
+
+## Quickstart
+
+A standard 2-second push-in, written next to the source image:
+
+```python
+from burns import ken_burns_video
+
+ken_burns_video("photo.jpg")          # → photo_kenburns.mp4
+```
+
+That's it. The result is an mp4 that slowly zooms into the center of `photo.jpg`.
+
+## A little more control
+
+The camera path is a list of **phases**, each `(start_rect, end_rect, duration_s)`.
+A *rect* is `(cx, cy, s)` — a pan center `(cx, cy)` in `[0, 1]` image units and a
+zoom scale `s` (`1.0` = the full frame, `> 1.0` = zoomed in). The camera moves
+linearly from `start_rect` to `end_rect` over `duration_s` seconds; phases play
+back-to-back.
+
+```python
+from burns import ken_burns_video
+
+# Pan from the full frame toward the upper-right while zooming in, over 5s.
+ken_burns_video(
+    "photo.jpg",
+    phases=[((0.5, 0.5, 1.0), (0.65, 0.40, 1.2), 5.0)],
+    saveas="out.mp4",
+)
+
+# A three-phase move: zoom in, pan across, settle back to center.
+ken_burns_video(
+    "photo.jpg",
+    phases=[
+        ((0.5, 0.5, 1.0), (0.65, 0.40, 1.2), 4.0),
+        ((0.65, 0.40, 1.2), (0.35, 0.60, 1.2), 4.0),
+        ((0.35, 0.60, 1.2), (0.5, 0.5, 1.3), 4.0),
+    ],
+)
+```
+
+Rects accept flexible shorthand: a bare number is a centered zoom (`1.3`), a pair
+is a pan center at full scale (`(0.3, 0.7)`), a triple is the full spec.
+
+## Let `burns` design the motion for you
+
+Hand-authoring rectangles for every image gets tedious. `ken_burns_path` generates
+a cohesive, **deterministic, non-repetitive** path from a few intent parameters —
+pass the image's position (`index`) and a duration, and it picks the framing:
+
+```python
+from burns import ken_burns_video, ken_burns_path
+
+# index seeds the focal direction; odd indices push in, even pull out.
+ken_burns_video("photo.jpg", phases=ken_burns_path(1, 5.0))
+
+# styles: "push" (zoom-led, the default) or "drift" (pure horizontal pan)
+ken_burns_video("photo.jpg", phases=ken_burns_path(2, 5.0, style="drift"))
+
+# ease=True replaces constant velocity with a slow-fast-slow curve
+ken_burns_video("photo.jpg", phases=ken_burns_path(1, 6.0, ease=True))
+```
+
+## Multi-image films
+
+`ken_burns_film` renders a sequence of `(image, phases)` panels as **one
+continuous film** — a single encode pass, so there are no concatenation seams and
+no per-image freeze frames at the cuts. Pass an optional pre-built audio track to
+mux it in.
+
+```python
+from burns import ken_burns_film, ken_burns_path
+
+panels = [
+    ("a.jpg", ken_burns_path(1, 4.0)),
+    ("b.jpg", ken_burns_path(2, 4.0)),
+    ("c.jpg", ken_burns_path(3, 4.0)),
+]
+ken_burns_film(panels, saveas="film.mp4", fps=30, audio_path="narration.mp3")
+```
+
+## API
+
+| Function | What it does |
+|----------|--------------|
+| `ken_burns_video(image, *, phases=..., fps=30, saveas=None, ...)` | Render one image into a multi-phase pan/zoom mp4. Accepts a path, a `PIL.Image`, or a numpy array. |
+| `ken_burns_film(panels, *, saveas, fps=30, audio_path=None, ...)` | Render a sequence of `(image, phases)` panels as one continuous film, with optional audio. |
+| `ken_burns_path(index, duration_s, *, style="push", zoom=1.10, pan=0.03, ease=False)` | Generate a deterministic pan/zoom path (the `phases` the renderers consume). |
+
+All rectangles are `(cx, cy, s)` — pan center in `[0, 1]`, zoom scale (`1.0` = full
+frame). Because the crop box is clamped to the image, you cannot zoom out past the
+original; express a zoom-out as a start `s > 1` panning to an end `s = 1`.

burns-0.0.0/burns/__init__.py

@@ -0,0 +1,48 @@
+"""burns — Ken Burns pan/zoom video effects.
+
+Turn a still image (or a sequence of stills) into a cinematic pan/zoom film.
+
+Three building blocks:
+
+- :func:`ken_burns_video` — render one image into a multi-phase pan/zoom mp4.
+- :func:`ken_burns_film` — render a sequence of ``(image, phases)`` panels as
+  one continuous film (no concat seams, no per-panel freezes), with optional
+  audio.
+- :func:`ken_burns_path` — generate a cohesive, non-repetitive pan/zoom *path*
+  (the ``phases`` the renderers consume) from a few intent parameters.
+
+Quickstart:
+
+    >>> from burns import ken_burns_video, ken_burns_path
+    >>> ken_burns_video("photo.jpg")  # standard 2s push-in  # doctest: +SKIP
+    >>> ken_burns_video(  # path generated per index/style  # doctest: +SKIP
+    ...     "photo.jpg", phases=ken_burns_path(1, 5.0, style="push", ease=True)
+    ... )
+
+Rectangles everywhere are ``(cx, cy, s)`` — pan center in ``[0, 1]`` and zoom
+scale (``1.0`` = full frame). See :func:`ken_burns_video` for the full spec.
+"""
+
+from burns.render import (
+    ken_burns_video,
+    ken_burns_film,
+    DEFAULT_KENBURNS_PHASES,
+)
+from burns.paths import (
+    ken_burns_path,
+    KenBurnsRect,
+    KenBurnsPhase,
+    KenBurnsPath,
+    PanelInput,
+)
+
+__all__ = [
+    "ken_burns_video",
+    "ken_burns_film",
+    "ken_burns_path",
+    "DEFAULT_KENBURNS_PHASES",
+    "KenBurnsRect",
+    "KenBurnsPhase",
+    "KenBurnsPath",
+    "PanelInput",
+]

burns-0.0.0/burns/_util.py

@@ -0,0 +1,78 @@
+"""Internal helpers for :mod:`burns` — output-path resolution and
+collision-safe naming.
+
+These are deliberately self-contained so ``burns`` carries no dependency
+beyond ``numpy`` / ``moviepy`` / ``pillow``.
+"""
+
+from pathlib import Path
+from typing import Container
+
+
+def _auto_video_path(src_path: str, suffix: str, *, ext: str | None = None) -> Path:
+    """Generate an output video path by appending ``suffix`` to the stem.
+
+    Args:
+        src_path: Source file path (image or video).
+        suffix: Suffix to add to the stem (e.g. ``"_kenburns"``).
+        ext: Optional extension override (e.g. ``".mp4"``).
+
+    Returns:
+        Path with format ``{stem}{suffix}{ext}``.
+
+    Examples:
+        >>> str(_auto_video_path("photo.jpg", "_kenburns", ext=".mp4"))
+        'photo_kenburns.mp4'
+    """
+    src = Path(src_path)
+    output = src.with_stem(f"{src.stem}{suffix}")
+    if ext:
+        output = output.with_suffix(ext)
+    return output
+
+
+def _ensure_output_path(path: str | Path) -> Path:
+    """Convert to :class:`~pathlib.Path` and ensure the parent directory exists.
+
+    Examples:
+        >>> import tempfile
+        >>> from pathlib import Path
+        >>> tmp = Path(tempfile.mkdtemp())
+        >>> out = _ensure_output_path(tmp / "sub" / "film.mp4")
+        >>> out.parent.exists()
+        True
+    """
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def _non_colliding_key(
+    key: str, exclude: Container[str], *, max_attempts: int = 10000
+) -> str:
+    """Return a filename not present in ``exclude``.
+
+    If ``key`` is already unique it is returned as-is; otherwise a
+    ``" (N)"`` suffix is inserted before the extension until a free name is
+    found. Mirrors ``dol.non_colliding_key``'s default string behavior so
+    auto-named renders never silently overwrite an existing file.
+
+    Examples:
+        >>> _non_colliding_key("film.mp4", set())
+        'film.mp4'
+        >>> _non_colliding_key("film.mp4", {"film.mp4"})
+        'film (1).mp4'
+        >>> _non_colliding_key("film.mp4", {"film.mp4", "film (1).mp4"})
+        'film (2).mp4'
+    """
+    if key not in exclude:
+        return key
+    p = Path(key)
+    stem, suffix = p.stem, p.suffix
+    for attempt in range(1, max_attempts + 1):
+        candidate = f"{stem} ({attempt}){suffix}"
+        if candidate not in exclude:
+            return candidate
+    raise ValueError(
+        f"_non_colliding_key: no free name for {key!r} within {max_attempts} attempts"
+    )

burns-0.0.0/burns/paths.py

@@ -0,0 +1,180 @@
+"""Deterministic Ken Burns pan/zoom **paths**.
+
+A *path* is a list of ``(start_rect, end_rect, duration_s)`` phases describing
+how the virtual camera moves over a single still image. :func:`ken_burns_path`
+builds such a path from a small set of intent parameters (style, zoom, pan,
+ease) so a sequence of images gets cohesive, non-repetitive motion without the
+caller hand-authoring rectangles.
+
+Rectangles are ``(cx, cy, s)`` — pan center ``(cx, cy)`` in ``[0, 1]`` image
+units and zoom scale ``s`` (``1.0`` = full frame, ``> 1.0`` = zoomed in). This
+is the same rectangle parameterization the renderers in :mod:`burns.render`
+consume, so a path drops straight into :func:`burns.ken_burns_video` (as its
+``phases``) or :func:`burns.ken_burns_film` (as a panel's phases).
+
+The functions here are **pure** — they map intent to geometry with no I/O — so
+they are cheap to unit-test and produce identical paths for identical inputs.
+"""
+
+from __future__ import annotations
+
+import math
+
+# A single (start_rect, end_rect, duration_s) segment of a path.
+# Rect is (cx, cy, s) — pan center in [0, 1] and zoom scale (1.0 = full).
+KenBurnsRect = tuple[float, float, float]
+KenBurnsPhase = tuple[KenBurnsRect, KenBurnsRect, float]
+KenBurnsPath = list[KenBurnsPhase]
+
+# A single panel input to a film renderer: image to animate + its pan/zoom
+# path. Audio, when present, is supplied separately as one combined track for
+# the whole film, so the renderer stays pure visual.
+from pathlib import Path  # noqa: E402  (kept next to the alias that uses it)
+
+PanelInput = tuple[Path, KenBurnsPath]
+
+
+_EASE_PHASES: tuple[tuple[float, float], ...] = (
+    (0.25, 0.10),  # slow start: 25% of time covers 10% of motion
+    (0.50, 0.70),  # mid:        50% of time covers 70% of motion
+    (0.25, 0.20),  # slow end:   25% of time covers 20% of motion
+)
+"""Three (time_fraction, motion_fraction) phases approximating a quadratic
+ease. Slow-fast-slow — preserves single-direction motion while losing the
+"robotic" constant-velocity feel."""
+
+
+_VALID_STYLES = ("push", "drift")
+
+
+def ken_burns_path(
+    index: int,
+    duration_s: float,
+    *,
+    style: str = "push",
+    zoom: float = 1.10,
+    pan: float = 0.03,
+    ease: bool = False,
+) -> KenBurnsPath:
+    """A deterministic pan/zoom path for one image.
+
+    Two named styles, opt-in ease curve:
+
+    - ``style="push"`` (default) — the "cinematic push". One slow zoom
+      (dominant motion) plus a subtle pan toward an off-center focal
+      point. Odd indices push *in*, even indices pull *out* — a sequence
+      of images has visual rhythm without changing direction *within*
+      a shot.
+
+    - ``style="drift"`` — pure horizontal pan, no zoom variance,
+      alternating direction per index. Useful for museum-style sequences
+      where the dominant motion should be pan, not zoom.
+
+    - ``ease=True`` — splits the single-phase motion into three phases
+      (slow-start, mid, slow-end) approximating a quadratic ease.
+      Velocity changes; direction and total magnitude do not.
+
+    Per-index deterministic: same args always return the same path.
+
+    Args:
+        index: the image's 1-based position in the sequence (seeds the
+            focal-point direction and the push-in/pull-out alternation).
+        duration_s: total time the path should cover, in seconds.
+        style: ``"push"`` (default) or ``"drift"``.
+        zoom: the zoomed-end scale (> 1.0). Ignored for ``"drift"`` —
+            drift uses a single constant zoom end-to-end (currently 1.0).
+        pan: how far the framing drifts off-center, in [0, 1] image
+            units. For ``"push"`` it controls focal-point offset; for
+            ``"drift"`` it is the total horizontal distance covered.
+        ease: when True, split the single phase into the slow-fast-slow
+            3-phase ease curve.
+
+    Returns:
+        A :data:`KenBurnsPath` — a list of ``(start_rect, end_rect,
+        duration_s)`` phases whose durations sum to ``duration_s``.
+
+    Examples:
+        >>> ken_burns_path(1, 5.0)
+        [((0.5, 0.5, 1.0), (0.4788, 0.5212, 1.1), 5.0)]
+        >>> ken_burns_path(2, 5.0)[0][2]  # one phase, full duration
+        5.0
+        >>> len(ken_burns_path(1, 6.0, ease=True))  # slow-fast-slow
+        3
+    """
+    if duration_s <= 0:
+        raise ValueError(f"ken_burns_path: duration_s must be > 0, got {duration_s}")
+    if style not in _VALID_STYLES:
+        raise ValueError(
+            f"ken_burns_path: style must be one of {_VALID_STYLES}, got {style!r}"
+        )
+
+    start, end = _endpoints_for_style(style, index, zoom=zoom, pan=pan)
+    if not ease:
+        return [(start, end, duration_s)]
+    return _split_with_ease(start, end, duration_s)
+
+
+def _endpoints_for_style(
+    style: str, index: int, *, zoom: float, pan: float
+) -> tuple[KenBurnsRect, KenBurnsRect]:
+    """Return the ``(start_rect, end_rect)`` for one image under one style."""
+    if style == "push":
+        # The focal-point direction cycles through compass octants per index —
+        # each image zooms toward (or pulls back from) a different corner.
+        angle = (index * 2 + 1) * (math.pi / 4)
+        off_cx = round(0.5 + pan * math.cos(angle), 4)
+        off_cy = round(0.5 + pan * math.sin(angle), 4)
+        center: KenBurnsRect = (0.5, 0.5, 1.0)
+        offset: KenBurnsRect = (off_cx, off_cy, zoom)
+        if index % 2 == 1:
+            return center, offset  # push in
+        return offset, center  # pull out
+
+    # style == "drift": purely horizontal pan, constant zoom.
+    # Alternate direction per index — odd drifts right, even drifts left.
+    direction = 1 if index % 2 == 1 else -1
+    # The drift distance scales with `pan`; we use a wider default offset
+    # than the push style because there is no zoom rhythm to share the
+    # frame budget with. A `pan` of 0.03 gives a noticeable but not
+    # frenetic horizontal slide; the renderer's clamp handles the edge.
+    half = pan
+    start_cx = round(0.5 - direction * half, 4)
+    end_cx = round(0.5 + direction * half, 4)
+    # A flat (no-variance) zoom keeps the dominant motion lateral; we use
+    # 1.0 so the renderer never crops more than the image's full frame —
+    # the eye reads a pure pan and the off-center crop window slides.
+    drift_zoom = 1.0
+    return (
+        (start_cx, 0.5, drift_zoom),
+        (end_cx, 0.5, drift_zoom),
+    )
+
+
+def _split_with_ease(
+    start: KenBurnsRect, end: KenBurnsRect, duration_s: float
+) -> KenBurnsPath:
+    """Break ``[start → end]`` into the slow-fast-slow 3-phase ease curve.
+
+    The straight-line motion is identical; only the *velocity* changes
+    along the way. Each phase's time fraction and motion fraction come
+    from :data:`_EASE_PHASES`. The chain is continuous — phase N+1
+    starts exactly where phase N ended.
+    """
+    phases: KenBurnsPath = []
+    cumulative_motion = 0.0
+    last_point = start
+    for time_frac, motion_frac in _EASE_PHASES:
+        cumulative_motion += motion_frac
+        next_point = _interp_rect(start, end, cumulative_motion)
+        phases.append((last_point, next_point, duration_s * time_frac))
+        last_point = next_point
+    return phases
+
+
+def _interp_rect(a: KenBurnsRect, b: KenBurnsRect, t: float) -> KenBurnsRect:
+    """Linear interpolation between two ``(cx, cy, s)`` rectangles."""
+    return (
+        round(a[0] + (b[0] - a[0]) * t, 6),
+        round(a[1] + (b[1] - a[1]) * t, 6),
+        round(a[2] + (b[2] - a[2]) * t, 6),
+    )

burns-0.0.0/burns/render.py

@@ -0,0 +1,446 @@
+"""Ken Burns **renderers** — turn still images into pan/zoom video.
+
+Two entry points, both backed by a lazy ``moviepy.VideoClip`` so the whole
+clip is never materialised in memory:
+
+- :func:`ken_burns_video` — one image, a multi-phase pan/zoom, one mp4.
+- :func:`ken_burns_film` — a sequence of ``(image, phases)`` panels rendered
+  as a **single** continuous film (no per-panel intermediate files, no concat
+  seams, no per-panel tail freezes), with an optional pre-built audio track
+  muxed in.
+
+Both consume the ``(cx, cy, s)`` rectangle spec described under
+:func:`ken_burns_video`. Use :func:`burns.ken_burns_path` to generate cohesive
+multi-phase paths instead of hand-authoring rectangles.
+"""
+
+import os
+import tempfile
+from pathlib import Path
+
+import numpy as np
+import moviepy as mp
+from PIL import Image as PIL_Image
+
+from ._util import _auto_video_path, _ensure_output_path, _non_colliding_key
+
+_VIDEO_EXTS = (".mp4", ".mov", ".avi", ".mkv")
+
+
+def _parse_rectangle(rect, default=(0.5, 0.5, 1.0)):
+    """Normalize a rectangle input to a ``(cx, cy, s)`` tuple.
+
+    Accepts:
+        - ``None``: returns ``default``
+        - single number: ``(0.5, 0.5, value)`` (a centered zoom)
+        - pair: ``(cx, cy, 1.0)`` (a pan center at full scale)
+        - triple: ``(cx, cy, s)`` (the full spec)
+    """
+    if rect is None:
+        return default
+    if isinstance(rect, (int, float)):
+        return (0.5, 0.5, float(rect))
+    if isinstance(rect, (list, tuple)):
+        if len(rect) == 1:
+            return (0.5, 0.5, float(rect[0]))
+        elif len(rect) == 2:
+            return (float(rect[0]), float(rect[1]), 1.0)
+        elif len(rect) == 3:
+            return (float(rect[0]), float(rect[1]), float(rect[2]))
+    raise ValueError(f"Invalid rectangle: {rect}")
+
+
+def _rect_to_box(cx, cy, s, img_w, img_h):
+    """Convert ``(cx, cy, s)`` to a pixel crop box ``(xmin, ymin, xmax, ymax)``.
+
+    The crop's width and height in pixels are ``img_w / s`` and ``img_h / s``
+    respectively — same aspect ratio as the source image, so the resize-back-to-
+    ``(img_w, img_h)`` step that follows never stretches the frame.
+
+    Pan-center clamping: when ``(cx, cy)`` would push the crop past an edge, we
+    clamp the **center**, not the crop box. Clamping the box itself shrinks one
+    side and breaks the aspect ratio — that was the source of the breathing /
+    stretching artefact in long pans. By clamping the center, the box "rides
+    the wall" at the edge but stays the right size.
+    """
+    half_w = 0.5 / s
+    half_h = 0.5 / s
+    # Clamp the pan center so the crop box fits inside the image. When zoom
+    # s <= 1.0, half_w >= 0.5 → the valid range collapses to {0.5} (i.e. the
+    # only legal center is the image middle); ``max(low, min(high, x))`` is
+    # robust to that case because ``min(...)`` still returns 0.5.
+    cx = max(half_w, min(1.0 - half_w, cx))
+    cy = max(half_h, min(1.0 - half_h, cy))
+    xmin = (cx - half_w) * img_w
+    ymin = (cy - half_h) * img_h
+    xmax = (cx + half_w) * img_w
+    ymax = (cy + half_h) * img_h
+    # Round (not truncate) for symmetric int conversion — the ±1 px drift
+    # from truncation can also nudge aspect ratio on extreme zooms.
+    return (
+        int(round(xmin)),
+        int(round(ymin)),
+        int(round(xmax)),
+        int(round(ymax)),
+    )
+
+
+DEFAULT_KENBURNS_PHASES = (((0.5, 0.5, 1.0), (0.5, 0.5, 1.3), 2.0),)
+
+
+def ken_burns_video(
+    image,
+    *,
+    phases=DEFAULT_KENBURNS_PHASES,
+    fps: int = 30,
+    saveas: str | None = None,
+    codec: str = "libx264",
+    audio_codec: str = "aac",
+    **write_kwargs,
+) -> Path:
+    """Create a Ken Burns effect video from an image with multi-phase pan/zoom.
+
+    Args:
+        image: Path to image file or image object (PIL.Image, np.ndarray)
+        phases: Iterable of ``(start_rect, end_rect, duration_s)`` phases. The
+            camera moves linearly from ``start_rect`` to ``end_rect`` over each
+            phase's ``duration_s``; phases play back-to-back so total clip
+            length is the sum of their durations. Default is a single 2-second
+            standard Ken Burns push-in.
+        fps: Frames per second (default 30)
+        saveas: Where to save video (default: image path with "_kenburns" appended before extension)
+        codec: Video codec (default libx264)
+        audio_codec: Audio codec (default aac)
+        **write_kwargs: Passed to write_videofile
+
+    Returns:
+        Path to saved video
+
+    Rectangle parameterization:
+        Rect = (cx, cy, s) — pan center (cx, cy) in [0, 1] and zoom scale s > 0.
+        s = 1: the full image; s > 1: zoomed in (a smaller crop box).
+        The crop box is clamped to the image, so you cannot zoom out past the
+        original — express a zoom-out as start s > 1 panning to end s = 1.
+        Standard Ken Burns: the full image (s=1) zooming in to s=1.3.
+        Rects accept the same flexible forms as elsewhere: a scalar zoom, a
+        (cx, cy) pan pair, or the full (cx, cy, s) triple.
+
+    Phase continuity:
+        A phase's ``end_rect`` does not need to match the next phase's
+        ``start_rect`` — discontinuities are allowed and produce an
+        instantaneous cut. For continuous motion, set each phase's
+        ``start_rect`` equal to the previous phase's ``end_rect``.
+
+    Examples:
+        >>> ken_burns_video("photo.jpg")  # Standard 2s push-in  # doctest: +SKIP
+        >>> ken_burns_video(  # doctest: +SKIP
+        ...     "photo.jpg",
+        ...     phases=[((0.5, 0.5, 1.0), (0.65, 0.4, 1.2), 5.0)],
+        ... )
+        >>> ken_burns_video(  # doctest: +SKIP
+        ...     "photo.jpg",
+        ...     phases=[
+        ...         ((0.5, 0.5, 1.0), (0.65, 0.4, 1.2), 4.0),
+        ...         ((0.65, 0.4, 1.2), (0.35, 0.6, 1.2), 4.0),
+        ...         ((0.35, 0.6, 1.2), (0.5, 0.5, 1.3), 4.0),
+        ...     ],
+        ... )
+    """
+    # Accept image as path, PIL.Image, or np.ndarray.
+    # Track the original image path for output path generation.
+    image_path = None
+    if isinstance(image, (str, Path)):
+        image_path = Path(image)
+        img = PIL_Image.open(str(image)).convert("RGB")
+    elif isinstance(image, np.ndarray):
+        img = PIL_Image.fromarray(image)
+    elif hasattr(image, "convert"):
+        img = image.convert("RGB")
+    else:
+        raise ValueError(f"Unsupported image type: {type(image)}")
+
+    img_w, img_h = img.size
+    img_np = np.array(img)  # preload once for fast per-frame cropping
+
+    # Normalize phases: each entry → (start_rect, end_rect, duration_s).
+    parsed_phases: list[tuple[tuple, tuple, float]] = []
+    for i, phase in enumerate(phases):
+        if not isinstance(phase, (list, tuple)) or len(phase) != 3:
+            raise ValueError(
+                f"phase {i}: expected (start_rect, end_rect, duration_s), got {phase!r}"
+            )
+        start_rect = _parse_rectangle(phase[0], default=(0.5, 0.5, 1.0))
+        end_rect = _parse_rectangle(phase[1], default=(0.5, 0.5, 1.3))
+        dur = float(phase[2])
+        if dur <= 0:
+            raise ValueError(f"phase {i}: duration_s must be > 0, got {dur}")
+        parsed_phases.append((start_rect, end_rect, dur))
+    if not parsed_phases:
+        raise ValueError("ken_burns_video: phases must be non-empty")
+
+    duration_s = sum(p[2] for p in parsed_phases)
+    # Cumulative phase-start times for fast lookup at frame time.
+    cum_starts = [0.0]
+    for _, _, dur in parsed_phases:
+        cum_starts.append(cum_starts[-1] + dur)
+
+    def _lerp(a, b, t):
+        return a + (b - a) * t
+
+    def _ken_burns_frame(t):
+        """Render the pan/zoom frame at time ``t`` (seconds), one frame at a time.
+
+        Computed lazily so the whole clip is never materialised in memory.
+        Picks the active phase by ``t`` and lerps linearly within it; clamps
+        to the last phase's end-rect once ``t`` reaches the total duration.
+        """
+        if t >= duration_s:
+            start_rect, end_rect, _ = parsed_phases[-1]
+            cx, cy, s = end_rect
+        else:
+            # Linear scan is fine — a film typically has < 20 phases per image.
+            for idx, (start_rect, end_rect, dur) in enumerate(parsed_phases):
+                if t < cum_starts[idx + 1]:
+                    local_t = (t - cum_starts[idx]) / dur
+                    cx = _lerp(start_rect[0], end_rect[0], local_t)
+                    cy = _lerp(start_rect[1], end_rect[1], local_t)
+                    s = _lerp(start_rect[2], end_rect[2], local_t)
+                    break
+            else:  # pragma: no cover — covered by the t >= duration_s branch
+                start_rect, end_rect, _ = parsed_phases[-1]
+                cx, cy, s = end_rect
+        xmin, ymin, xmax, ymax = _rect_to_box(cx, cy, s, img_w, img_h)
+        crop = img_np[ymin:ymax, xmin:xmax]
+        crop_img = PIL_Image.fromarray(crop).resize(
+            (img_w, img_h), resample=PIL_Image.BICUBIC
+        )
+        return np.asarray(crop_img)
+
+    # Determine output path.
+    if saveas is None:
+        if image_path is not None:
+            # Append "_kenburns" to the source image's filename.
+            output_path = _auto_video_path(str(image_path), "_kenburns", ext=".mp4")
+        else:
+            # Fallback to temp directory when there is no source path.
+            output_path = Path(tempfile.gettempdir()) / f"kenburns_{os.getpid()}.mp4"
+    else:
+        output_path = _ensure_output_path(saveas)
+        # Ensure it has a video extension.
+        if not output_path.suffix or output_path.suffix.lower() not in _VIDEO_EXTS:
+            output_path = output_path.with_suffix(".mp4")
+
+    # Avoid overwriting an existing auto-generated path.
+    if saveas is None:
+        directory = output_path.parent
+        filename = output_path.name
+        try:
+            existing_files = (
+                set(os.listdir(directory)) if directory else set(os.listdir("."))
+            )
+        except OSError:
+            existing_files = set()
+        if filename in existing_files:
+            output_path = directory / _non_colliding_key(filename, existing_files)
+
+    # Create the clip lazily: frames are computed on demand during encoding.
+    clip = mp.VideoClip(_ken_burns_frame, duration=duration_s).with_fps(fps)
+
+    # Set default kwargs for better compatibility.
+    write_kwargs.setdefault("bitrate", "5000k")
+    write_kwargs.setdefault("preset", "medium")
+    write_kwargs.setdefault("logger", None)  # Suppress verbose output
+
+    clip.write_videofile(
+        str(output_path), codec=codec, audio_codec=audio_codec, **write_kwargs
+    )
+    clip.close()
+
+    print(f"Saved Ken Burns video to: {output_path}")
+    return output_path
+
+
+# --------------------------------------------------------------------- #
+# Multi-panel Ken Burns film
+# --------------------------------------------------------------------- #
+
+
+def ken_burns_film(
+    panels,
+    *,
+    saveas: str,
+    fps: int = 30,
+    audio_path=None,
+    codec: str = "libx264",
+    audio_codec: str = "aac",
+    **write_kwargs,
+) -> Path:
+    """Render an N-panel Ken Burns film in a single pass — no per-panel
+    intermediate files, no concat seams, no per-panel tail freezes.
+
+    Each panel is one ``(image, phases)`` pair where ``image`` is a path /
+    PIL.Image / np.ndarray and ``phases`` is the same shape as in
+    :func:`ken_burns_video`. The film plays panels back-to-back; the camera
+    cuts at panel boundaries (different image) but motion never pauses on
+    a static frame within a panel.
+
+    Args:
+        panels: iterable of ``(image, phases)`` pairs. Each panel's total
+            duration = sum of its phase durations. Film total = sum across
+            panels.
+        saveas: output mp4 path (required — multi-panel films don't have a
+            single source image to derive an auto-name from).
+        fps: frame rate of the film.
+        audio_path: optional pre-built audio track (already concatenated,
+            already matching the film duration). When supplied it is muxed
+            in. Per-panel audio is the caller's job to assemble — keep
+            the renderer pure visual.
+        codec, audio_codec, **write_kwargs: forwarded to ``write_videofile``.
+
+    Why a single VideoClip rather than per-panel render + concatenate:
+
+    - Concat re-encodes at I-frame boundaries; the last few frames of each
+      input clip can drop and the next clip's first frame may freeze
+      briefly. With one VideoClip the encoder writes a single stream.
+    - No per-panel tail-pad: the pan reaches the panel's last frame exactly
+      when the panel ends; the next frame is already the next panel's
+      first.
+    - Lazy frame generation: a single ``make_frame(t)`` closure dispatches
+      by global ``t`` to the right (panel, phase) — the whole film is
+      never materialised in memory.
+
+    Returns:
+        Path to the written mp4.
+    """
+    # Load each panel's image once; pre-parse phases.
+    panel_renders = []
+    film_duration = 0.0
+    for idx, panel in enumerate(panels):
+        if not isinstance(panel, (list, tuple)) or len(panel) != 2:
+            raise ValueError(
+                f"panel {idx}: expected (image, phases) pair, got {panel!r}"
+            )
+        image, phases = panel
+        if isinstance(image, (str, Path)):
+            img = PIL_Image.open(str(image)).convert("RGB")
+        elif isinstance(image, np.ndarray):
+            img = PIL_Image.fromarray(image)
+        elif hasattr(image, "convert"):
+            img = image.convert("RGB")
+        else:
+            raise ValueError(f"panel {idx}: unsupported image type: {type(image)}")
+        img_w, img_h = img.size
+        img_np = np.array(img)
+
+        parsed: list[tuple[tuple, tuple, float]] = []
+        for j, phase in enumerate(phases):
+            if not isinstance(phase, (list, tuple)) or len(phase) != 3:
+                raise ValueError(
+                    f"panel {idx}, phase {j}: expected (start, end, dur), got {phase!r}"
+                )
+            s = _parse_rectangle(phase[0], default=(0.5, 0.5, 1.0))
+            e = _parse_rectangle(phase[1], default=(0.5, 0.5, 1.3))
+            d = float(phase[2])
+            if d <= 0:
+                raise ValueError(
+                    f"panel {idx}, phase {j}: duration_s must be > 0, got {d}"
+                )
+            parsed.append((s, e, d))
+        if not parsed:
+            raise ValueError(f"panel {idx}: phases must be non-empty")
+
+        panel_dur = sum(p[2] for p in parsed)
+        cum = [0.0]
+        for _, _, d in parsed:
+            cum.append(cum[-1] + d)
+        panel_renders.append(
+            {
+                "img_np": img_np,
+                "img_w": img_w,
+                "img_h": img_h,
+                "phases": parsed,
+                "cum_starts": cum,
+                "duration": panel_dur,
+                "film_offset": film_duration,
+                "size": (img_w, img_h),
+            }
+        )
+        film_duration += panel_dur
+
+    if film_duration <= 0:
+        raise ValueError("ken_burns_film: panels must be non-empty")
+
+    # Common output frame size = first panel's size. When all panels share the
+    # same size (common for storyboard demos), every panel is rendered at its
+    # native size and no letter/pillar-boxing happens.
+    out_w, out_h = panel_renders[0]["size"]
+
+    def _lerp(a, b, t):
+        return a + (b - a) * t
+
+    def make_frame(t):
+        """Render the film's frame at global time ``t``.
+
+        Walks the panel list once per frame (typical film: < 50 panels —
+        cheap). Within a panel, linearly interpolates between the active
+        phase's start and end rect; clamps to the last phase's end-rect
+        when ``t`` lands exactly on a boundary (avoids a 1-frame flicker
+        at panel transitions).
+        """
+        if t >= film_duration:
+            pr = panel_renders[-1]
+            cx, cy, s = pr["phases"][-1][1]
+        else:
+            pr = None
+            for candidate in panel_renders:
+                if t < candidate["film_offset"] + candidate["duration"]:
+                    pr = candidate
+                    break
+            assert pr is not None  # guarded by t < film_duration
+            local_t = t - pr["film_offset"]
+            cx = cy = s = None
+            for idx, (start, end, dur) in enumerate(pr["phases"]):
+                if local_t < pr["cum_starts"][idx + 1]:
+                    inner = (local_t - pr["cum_starts"][idx]) / dur
+                    cx = _lerp(start[0], end[0], inner)
+                    cy = _lerp(start[1], end[1], inner)
+                    s = _lerp(start[2], end[2], inner)
+                    break
+            if cx is None:  # exactly on a boundary
+                start, end, _ = pr["phases"][-1]
+                cx, cy, s = end
+
+        img_w, img_h = pr["img_w"], pr["img_h"]
+        xmin, ymin, xmax, ymax = _rect_to_box(cx, cy, s, img_w, img_h)
+        crop = pr["img_np"][ymin:ymax, xmin:xmax]
+        # Resize the crop back to the film's output frame size. When panels
+        # are all the same size (common case), this equals the crop's own
+        # (img_w, img_h) and the aspect is preserved exactly.
+        crop_img = PIL_Image.fromarray(crop).resize(
+            (out_w, out_h), resample=PIL_Image.BICUBIC
+        )
+        return np.asarray(crop_img)
+
+    output_path = _ensure_output_path(saveas)
+    if not output_path.suffix or output_path.suffix.lower() not in _VIDEO_EXTS:
+        output_path = output_path.with_suffix(".mp4")
+
+    clip = mp.VideoClip(make_frame, duration=film_duration).with_fps(fps)
+    if audio_path is not None:
+        audio_clip = mp.AudioFileClip(str(audio_path))
+        clip = clip.with_audio(audio_clip)
+
+    write_kwargs.setdefault("bitrate", "5000k")
+    write_kwargs.setdefault("preset", "medium")
+    write_kwargs.setdefault("logger", None)
+
+    clip.write_videofile(
+        str(output_path), codec=codec, audio_codec=audio_codec, **write_kwargs
+    )
+    clip.close()
+
+    print(
+        f"Saved Ken Burns film ({len(panel_renders)} panels, "
+        f"{film_duration:.1f}s) to: {output_path}"
+    )
+    return output_path

burns-0.0.0/pyproject.toml

@@ -0,0 +1,168 @@
+[build-system]
+requires = [
+    "hatchling",
+]
+build-backend = "hatchling.build"
+
+[project]
+name = "burns"
+version = "0.0.0"
+description = "Ken Burns pan/zoom video effects: turn a still image (or a sequence of stills) into a cinematic pan/zoom film."
+readme = "README.md"
+requires-python = ">=3.10"
+keywords = [
+    "ken-burns",
+    "video",
+    "pan-zoom",
+    "moviepy",
+    "animation",
+    "slideshow",
+]
+authors = [
+    { name = "Thor Whalen" },
+]
+dependencies = [
+    "numpy",
+    "moviepy",
+    "pillow",
+]
+
+[project.license]
+text = "mit"
+
+[project.urls]
+Homepage = "https://github.com/thorwhalen/burns"
+Repository = "https://github.com/thorwhalen/burns"
+Documentation = "https://thorwhalen.github.io/burns"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+    "ruff>=0.1.0",
+]
+docs = [
+    "sphinx>=6.0",
+    "sphinx-rtd-theme>=1.0",
+]
+
+[tool.ruff]
+line-length = 88
+target-version = "py310"
+exclude = [
+    "**/*.ipynb",
+    ".git",
+    ".venv",
+    "build",
+    "dist",
+    "tests",
+    "examples",
+    "scrap",
+]
+
+[tool.ruff.lint]
+select = [
+    "D100",
+]
+ignore = [
+    "D203",
+    "E501",
+    "B905",
+]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.ruff.lint.per-file-ignores]
+"**/tests/*" = [
+    "D",
+]
+"**/examples/*" = [
+    "D",
+]
+"**/scrap/*" = [
+    "D",
+]
+
+[tool.pytest.ini_options]
+minversion = "6.0"
+testpaths = [
+    "tests",
+]
+doctest_optionflags = [
+    "NORMALIZE_WHITESPACE",
+    "ELLIPSIS",
+]
+
+[tool.wads.ci]
+project_name = ""
+
+[tool.wads.ci.commands]
+pre_test = []
+test = []
+post_test = []
+lint = []
+format = []
+
+[tool.wads.ci.env]
+required_envvars = []
+test_envvars = []
+extra_envvars = []
+
+[tool.wads.ci.env.defaults]
+
+[tool.wads.ci.quality.ruff]
+enabled = true
+
+[tool.wads.ci.quality.black]
+enabled = false
+
+[tool.wads.ci.quality.mypy]
+enabled = false
+
+[tool.wads.ci.testing]
+enabled = true
+python_versions = [
+    "3.10",
+    "3.12",
+]
+pytest_args = [
+    "-v",
+    "--tb=short",
+]
+coverage_enabled = true
+coverage_threshold = 0
+coverage_report_format = [
+    "term",
+    "xml",
+]
+exclude_paths = [
+    "examples",
+    "scrap",
+]
+test_on_windows = true
+
+[tool.wads.ci.metrics]
+enabled = true
+config_path = ".github/umpyre-config.yml"
+storage_branch = "code-metrics"
+python_version = "3.10"
+force_run = false
+
+[tool.wads.ci.build]
+sdist = true
+wheel = true
+
+[tool.wads.ci.publish]
+enabled = true
+skip_ci_marker = "[skip ci]"
+publish_marker = "[publish]"
+
+[tool.wads.ci.docs]
+enabled = true
+builder = "epythet"
+ignore_paths = [
+    "tests/",
+    "scrap/",
+    "examples/",
+]