keyed 0.1.0__tar.gz

keyed-0.1.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2024, Doug Mercer
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

keyed-0.1.0/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: keyed
+Version: 0.1.0
+Summary: A reactive animation library.
+Author-email: Doug Mercer <dougmerceryt@gmail.com>
+License: BSD 3-Clause License
+        
+        Copyright (c) 2024, Doug Mercer
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        1. Redistributions of source code must retain the above copyright notice, this
+           list of conditions and the following disclaimer.
+        
+        2. Redistributions in binary form must reproduce the above copyright notice,
+           this list of conditions and the following disclaimer in the documentation
+           and/or other materials provided with the distribution.
+        
+        3. Neither the name of the copyright holder nor the names of its
+           contributors may be used to endorse or promote products derived from
+           this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+        
+Keywords: keyed,animation,reactive
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: <3.13,>=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyav
+Requires-Dist: pillow
+Requires-Dist: pycairo
+Requires-Dist: pydantic
+Requires-Dist: pygments
+Requires-Dist: scipy
+Requires-Dist: shapely
+Requires-Dist: signified
+Requires-Dist: tqdm
+Requires-Dist: typer
+Provides-Extra: lint
+Requires-Dist: ruff; extra == "lint"
+Requires-Dist: pyright; extra == "lint"
+Provides-Extra: test
+Requires-Dist: hypothesis; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: syrupy; extra == "test"
+Provides-Extra: docs
+Requires-Dist: beautifulsoup4; extra == "docs"
+Requires-Dist: mkdocs; extra == "docs"
+Requires-Dist: mkdocs-material; extra == "docs"
+Requires-Dist: mkdocstrings[python]; extra == "docs"
+Requires-Dist: mkdocs-material-extensions; extra == "docs"
+Provides-Extra: previewer
+Requires-Dist: pyside6; extra == "previewer"
+Requires-Dist: watchdog; extra == "previewer"
+Provides-Extra: gpu-compositor
+Requires-Dist: taichi; extra == "gpu-compositor"
+Provides-Extra: all
+Requires-Dist: keyed[docs,gpu-compositor,lint,previewer,test]; extra == "all"
+Dynamic: license-file
+
+# Keyed
+
+[![PyPI - Downloads](https://img.shields.io/pypi/dw/keyed)](https://pypi.org/project/keyed/)
+[![PyPI - Version](https://img.shields.io/pypi/v/keyed)](https://pypi.org/project/keyed/)
+[![Tests Status](https://github.com/dougmercer/keyed/actions/workflows/tests.yml/badge.svg)](https://github.com/dougmercer/keyed/actions/workflows/tests.yml?query=branch%3Amain)
+
+---
+
+**Documentation**: [https://dougmercer.github.io/keyed](https://dougmercer.github.io/keyed)  
+**Source Code**: [https://github.com/dougmercer/keyed](https://github.com/dougmercer/keyed)
+
+---
+
+Keyed is a Python library for creating programmatically defined animations. Named after [key frames](https://en.wikipedia.org/wiki/Key_frame), the defining points in an animation sequence, Keyed makes it easy to create sophisticated animations through code.
+
+## Features
+
+- **Reactive Programming Model**: Built using the reactive programming library [signified](https://github.com/dougmercer/signified) to make declaratively defining highly dynamic animations a breeze
+- **Vector Graphics**: [Cairo](https://www.cairographics.org)-based rendering for crisp, scalable graphics
+- **Flexible Shape System**: Define basic lines, shapes, curves, and complex geometries
+- **Code Animation**: Animate syntax highled code snippets
+
+## Installation
+
+Keyed requires a couple system level dependencies (e.g., [Cairo](https://www.cairographics.org/download/) and [ffmpeg](https://www.ffmpeg.org/)).
+
+For detailed installation instructions visit our [Installation Guide](https://dougmercer.github.io/keyed/install)
+.
+
+But, once you have the necessary system dependencies installed, installing `keyed` is as simple as,
+
+```console
+pip install keyed
+```
+
+## Project Status
+
+This project is in beta, so APIs may change.
+
+## Alternatives
+While I find `keyed` very fun and useful (particularly for animating syntax highlighted code in my [YouTube videos](https://youtube.com/@dougmercer)), there are several other excellent and far more mature animation libraries that you should probably use instead.
+
+Before you decide to use `keyed`, be sure to check out:
+
+* [Manim](https://manim.community): Comprehensive mathematical animation system originally created by Grant Sanderson of the YouTube channel 3blue1brown, but later adopted and extended by the manim community.
+* [py5](https://py5coding.org): A Python wrapper for p5, the Java animation library.

keyed-0.1.0/README.md

@@ -0,0 +1,46 @@
+# Keyed
+
+[![PyPI - Downloads](https://img.shields.io/pypi/dw/keyed)](https://pypi.org/project/keyed/)
+[![PyPI - Version](https://img.shields.io/pypi/v/keyed)](https://pypi.org/project/keyed/)
+[![Tests Status](https://github.com/dougmercer/keyed/actions/workflows/tests.yml/badge.svg)](https://github.com/dougmercer/keyed/actions/workflows/tests.yml?query=branch%3Amain)
+
+---
+
+**Documentation**: [https://dougmercer.github.io/keyed](https://dougmercer.github.io/keyed)  
+**Source Code**: [https://github.com/dougmercer/keyed](https://github.com/dougmercer/keyed)
+
+---
+
+Keyed is a Python library for creating programmatically defined animations. Named after [key frames](https://en.wikipedia.org/wiki/Key_frame), the defining points in an animation sequence, Keyed makes it easy to create sophisticated animations through code.
+
+## Features
+
+- **Reactive Programming Model**: Built using the reactive programming library [signified](https://github.com/dougmercer/signified) to make declaratively defining highly dynamic animations a breeze
+- **Vector Graphics**: [Cairo](https://www.cairographics.org)-based rendering for crisp, scalable graphics
+- **Flexible Shape System**: Define basic lines, shapes, curves, and complex geometries
+- **Code Animation**: Animate syntax highled code snippets
+
+## Installation
+
+Keyed requires a couple system level dependencies (e.g., [Cairo](https://www.cairographics.org/download/) and [ffmpeg](https://www.ffmpeg.org/)).
+
+For detailed installation instructions visit our [Installation Guide](https://dougmercer.github.io/keyed/install)
+.
+
+But, once you have the necessary system dependencies installed, installing `keyed` is as simple as,
+
+```console
+pip install keyed
+```
+
+## Project Status
+
+This project is in beta, so APIs may change.
+
+## Alternatives
+While I find `keyed` very fun and useful (particularly for animating syntax highlighted code in my [YouTube videos](https://youtube.com/@dougmercer)), there are several other excellent and far more mature animation libraries that you should probably use instead.
+
+Before you decide to use `keyed`, be sure to check out:
+
+* [Manim](https://manim.community): Comprehensive mathematical animation system originally created by Grant Sanderson of the YouTube channel 3blue1brown, but later adopted and extended by the manim community.
+* [py5](https://py5coding.org): A Python wrapper for p5, the Java animation library.

keyed-0.1.0/pyproject.toml

@@ -0,0 +1,167 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "keyed"
+description = "A reactive animation library."
+version = "0.1.0"
+readme = "README.md"
+license = {file="LICENSE"}
+authors = [
+    {name = "Doug Mercer", email = "dougmerceryt@gmail.com"}
+]
+requires-python = ">=3.11,<3.13"  # taichi is most restrictive
+dependencies = [
+    "pyav",
+    "pillow",
+    "pycairo",
+    "pydantic",
+    "pygments",
+    "scipy",
+    "shapely",
+    "signified",
+    "tqdm",
+    "typer",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+keywords = ["keyed", "animation", "reactive"]
+
+
+[project.optional-dependencies]
+lint = [
+    "ruff",
+    "pyright",
+]
+test = [
+    "hypothesis",
+    "pytest",
+    "pytest-cov",
+    "syrupy",
+]
+docs = [
+    "beautifulsoup4",
+    "mkdocs",
+    "mkdocs-material",
+    "mkdocstrings[python]",
+    "mkdocs-material-extensions",
+]
+previewer = [
+    "pyside6",
+    "watchdog",
+]
+gpu-compositor = [
+    "taichi",
+]
+all = ["keyed[lint,test,docs,previewer,gpu-compositor]"]
+
+[tool.setuptools.package-data]
+keyed = ["py.typed"]
+
+[tool.pytest.ini_options]
+addopts = "--cov=src --cov-report=xml --junitxml=junit/test-results.xml --durations=10"
+filterwarnings = ["ignore::DeprecationWarning"]
+testpaths = ["tests", "src"]
+markers = {snapshot = "marks tests as snapshot (deselect with '-m \"not snapshot\"')"}
+
+[tool.coverage.report]
+exclude_also = [
+    "pragma: no cover",
+    "if TYPE_CHECKING:",
+    "pass"
+]
+
+[tool.ruff]
+# Exclude a variety of commonly ignored directories.
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".git-rewrite",
+    ".hg",
+    ".ipynb_checkpoints",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pyenv",
+    ".pytest_cache",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    ".vscode",
+    ".__pycache__",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "docs",
+    "envs",
+    "htmlcov",
+    "results",
+    "significant.egg-info",
+    "junk",
+    ".hypothesis",
+    "node_modules",
+    "site-packages",
+    "venv",
+]
+
+line-length = 120
+indent-width = 4
+target-version = "py39"
+
+[tool.ruff.lint]
+# Enable Pyflakes (`F`) and a subset of the pycodestyle (`E`)  codes by default.
+# Unlike Flake8, Ruff doesn't enable pycodestyle warnings (`W`) or
+# McCabe complexity (`C901`) by default.
+select = ["E4", "E7", "E9", "F", "I"]
+ignore = []
+
+# Allow fix for all enabled rules (when `--fix`) is provided.
+fixable = ["ALL"]
+unfixable = []
+
+# Allow unused variables when underscore-prefixed.
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+[tool.ruff.format]
+# Like Black, use double quotes for strings.
+quote-style = "double"
+
+# Like Black, indent with spaces, rather than tabs.
+indent-style = "space"
+
+# Like Black, respect magic trailing commas.
+skip-magic-trailing-comma = false
+
+# Like Black, automatically detect the appropriate line ending.
+line-ending = "auto"
+
+# Enable auto-formatting of code examples in docstrings. Markdown,
+# reStructuredText code/literal blocks and doctests are all supported.
+#
+# This is currently disabled by default, but it is planned for this
+# to be opt-out in the future.
+docstring-code-format = false
+
+# Set the line length limit used when formatting code snippets in
+# docstrings.
+#
+# This only has an effect when the `docstring-code-format` setting is
+# enabled.
+docstring-code-line-length = "dynamic"
+
+[tool.ruff.lint.isort]
+known-first-party = ["keyed_*", "helpers"]
+
+[project.scripts]
+keyed = "keyed.cli:main"

keyed-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

keyed-0.1.0/src/keyed/__init__.py

@@ -0,0 +1,38 @@
+"""A key-frame focused animation engine."""
+
+# Taichi makes it an absolute nightmare to squelch startup noise.
+import os
+
+os.environ["ENABLE_TAICHI_HEADER_PRINT"] = "False"
+try:
+    from taichi._logging import ERROR, set_logging_level  # noqa: E402  # type: ignore
+
+    set_logging_level(ERROR)
+    del set_logging_level
+except ImportError:
+    pass
+finally:
+    del os
+
+from . import easing  # noqa
+from . import highlight  # noqa
+from . import transforms  # noqa
+from .animation import *  # noqa
+from .annotations import *  # noqa
+from .base import *  # noqa
+from .text import *  # noqa
+from .constants import *  # noqa
+from .color import *  # noqa
+from .compositor import *  # noqa
+from .curve import *  # noqa
+from .effects import *  # noqa
+from .highlight import *  # noqa
+from .line import *  # noqa
+from .geometry import *  # noqa
+from .plot import *  # noqa
+from .scene import *  # noqa
+from .group import *  # noqa
+from .shapes import *  # noqa
+
+# This must go last
+from .extras import *  # noqa

keyed-0.1.0/src/keyed/animation.py

@@ -0,0 +1,278 @@
+"""Animation related classes/functions."""
+
+from __future__ import annotations
+
+from enum import Enum, auto
+from functools import partial
+from typing import Any, Generic, TypeVar
+
+from signified import Computed, HasValue, ReactiveValue, Signal, computed
+
+from .constants import ALWAYS
+from .easing import EasingFunctionT, easing_function, linear_in_out
+
+__all__ = [
+    "AnimationType",
+    "Animation",
+    "stagger",
+    "Loop",
+    "PingPong",
+    "step",
+]
+
+
+class AnimationType(Enum):
+    """Specifies the mathematical operation used to combine the original and animated values."""
+
+    MULTIPLY = auto()
+    """Multiplies the original value by the animated value."""
+    ABSOLUTE = auto()
+    """Replaces the original value with the animated value."""
+    ADD = auto()
+    """Adds the animated value to the original value."""
+
+
+T = TypeVar("T")
+A = TypeVar("A")
+
+
+class Animation(Generic[T]):
+    """Define an animation.
+
+    Animations vary a parameter over time.
+
+    Generally, Animations become active at ``start_frame`` and smoothly change
+    according to the ``easing`` function until terminating to a final value at
+    ``end_frame``. The animation will remain active (i.e., the parameter will
+    not suddenly jump back to it's pre-animation state), but will cease varying.
+
+    Args:
+        start: Frame at which the animation will become active.
+        end: Frame at which the animation will stop varying.
+        start_value: Value at which the animation will start.
+        end_value: Value at which the animation will end.
+        ease: The rate in which the value will change throughout the animation.
+        animation_type: How the animation value will affect the original value.
+
+    Raises:
+        ValueError: When ``start_frame > end_frame``
+    """
+
+    def __init__(
+        self,
+        start: int,
+        end: int,
+        start_value: HasValue[T],
+        end_value: HasValue[T],
+        ease: EasingFunctionT = linear_in_out,
+        animation_type: AnimationType = AnimationType.ABSOLUTE,
+    ) -> None:
+        if start > end:
+            raise ValueError("Ending frame must be after starting frame.")
+        if not hasattr(self, "start_frame"):
+            self.start_frame = start
+        if not hasattr(self, "end_frame"):
+            self.end_frame = end
+        self.start_value = start_value
+        self.end_value = end_value
+        self.ease = ease
+        self.animation_type = animation_type
+
+    def __call__(self, value: HasValue[A], frame: ReactiveValue[int]) -> Computed[A | T]:
+        """Bind the animation to the input value and frame."""
+        easing = easing_function(start=self.start_frame, end=self.end_frame, ease=self.ease, frame=frame)
+
+        @computed
+        def f(value: A, frame: int, easing: float, start: T, end: T) -> A | T:
+            eased_value = end * easing + start * (1 - easing)  # pyright: ignore[reportOperatorIssue] # noqa: E501
+
+            match self.animation_type:
+                case AnimationType.ABSOLUTE:
+                    pass
+                case AnimationType.ADD:
+                    eased_value = value + eased_value
+                case AnimationType.MULTIPLY:
+                    eased_value = value * eased_value
+                case _:
+                    raise ValueError("Undefined AnimationType")
+
+            return value if frame < self.start_frame else eased_value
+
+        return f(value, frame, easing, self.start_value, self.end_value)
+
+    def __len__(self) -> int:
+        """Return number of frames in the animation."""
+        return self.end_frame - self.start_frame + 1
+
+
+class Loop(Animation):
+    """Loop an animation.
+
+    Args:
+        animation: The animation to loop.
+        n: Number of times to loop the animation.
+    """
+
+    def __init__(self, animation: Animation, n: int = 1):
+        self.animation = animation
+        self.n = n
+        super().__init__(self.start_frame, self.end_frame, 0, 0)
+
+    @property
+    def start_frame(self) -> int:  # type: ignore[override]
+        """Frame at which the animation will become active."""
+        return self.animation.start_frame
+
+    @property
+    def end_frame(self) -> int:  # type: ignore[override]
+        """Frame at which the animation will stop varying."""
+        return self.animation.start_frame + len(self.animation) * self.n
+
+    def __call__(self, value: HasValue[T], frame: ReactiveValue[int]) -> Computed[T]:
+        """Apply the animation to the current value at the current frame.
+
+        Args:
+            frame: The frame at which the animation is applied.
+            value: The initial value.
+
+        Returns:
+            The value after the animation.
+        """
+        effective_frame = self.animation.start_frame + (frame - self.animation.start_frame) % len(self.animation)
+        active_anim = self.animation(value, effective_frame)
+        post_anim = self.animation(value, Signal(self.animation.end_frame))
+
+        @computed
+        def f(frame: int, value: Any, active_anim: Any, post_anim: Any) -> Any:
+            if frame < self.start_frame:
+                return value
+            elif frame < self.end_frame:
+                return active_anim
+            else:
+                return post_anim
+
+        return f(frame, value, active_anim, post_anim)
+
+    def __repr__(self) -> str:
+        return f"Loop(animation={self.animation}, n={self.n})"
+
+
+class PingPong(Animation):
+    """Play an animation forward, then backwards n times.
+
+    Args:
+        animation: The animation to ping-pong.
+        n: Number of full back-and-forth cycles
+    """
+
+    def __init__(self, animation: Animation, n: int = 1):
+        self.animation = animation
+        self.n = n
+        super().__init__(self.start_frame, self.end_frame, 0, 0)
+
+    @property
+    def start_frame(self) -> int:  # type: ignore[override]
+        """Returns the frame at which the animation begins."""
+        return self.animation.start_frame
+
+    @property
+    def end_frame(self) -> int:  # type: ignore[override]
+        """Returns the frame at which the animation stops varying.
+
+        Notes:
+            Each cycle consists of going forward and coming back.
+        """
+        return self.animation.start_frame + self.cycle_len * self.n
+
+    @property
+    def cycle_len(self) -> int:
+        """Returns the number of frames in one cycle."""
+        return 2 * (len(self.animation) - 1)
+
+    def __call__(self, value: HasValue[T], frame: ReactiveValue[int]) -> Computed[T]:
+        """Apply the animation to the current value at the current frame.
+
+        Args:
+            frame: The frame at which the animation is applied.
+            value: The initial value.
+
+        Returns:
+            The value after the animation.
+        """
+
+        # Calculate effective frame based on whether we're in the forward or backward cycle
+        @computed
+        def effective_frame_(frame: int) -> int:
+            frame_in_cycle = (frame - self.start_frame) % self.cycle_len
+            return (
+                self.animation.start_frame + frame_in_cycle
+                if frame_in_cycle < len(self.animation)
+                else self.animation.end_frame - (frame_in_cycle - len(self.animation) + 1)
+            )
+
+        effective_frame = effective_frame_(frame)
+        anim = self.animation(value, effective_frame)
+
+        @computed
+        def f(frame: int, value: Any) -> Any:
+            return value if frame < self.start_frame or frame > self.end_frame else anim.value
+
+        return f(frame, value)
+
+    def __repr__(self) -> str:
+        return f"PingPong(animation={self.animation}, n={self.n})"
+
+
+def stagger(
+    start_value: float = 0,
+    end_value: float = 1,
+    easing: EasingFunctionT = linear_in_out,
+    animation_type: AnimationType = AnimationType.ABSOLUTE,
+) -> partial[Animation]:
+    """Partially-initialize an animation for use with [Group.write_on][keyed.group.Group.write_on].
+
+    This will set the animations values, easing, and type without setting its start/end frames.
+
+    Args:
+        start_value: Value at which the animation will start.
+        end_value: Value at which the animation will end.
+        easing: The rate in which the value will change throughout the animation.
+        animation_type: How the animation value will affect the original value.
+
+    Returns:
+        Partially initialized animation.
+    """
+    return partial(
+        Animation,
+        start_value=start_value,
+        end_value=end_value,
+        ease=easing,
+        animation_type=animation_type,
+    )
+
+
+def step(
+    value: HasValue[T], frame: int = ALWAYS, animation_type: AnimationType = AnimationType.ABSOLUTE
+) -> Animation[T]:
+    """Return an animation that applies a step function to the Variable at a particular frame.
+
+    Args:
+        value: The value to step to.
+        frame: The frame at which the step will be applied.
+        animation_type: See :class:`AnimationType`.
+
+    Returns:
+        An animation that applies a step function to the Variable at a particular frame.
+    """
+    # Can this be simpler? Something like...
+    # def step_builder(initial_value: HasValue[A], frame_rx: ReactiveValue[int]) -> Computed[A|T]:
+    #     return (frame_rx >= frame).where(value, initial_value)
+
+    # return step_builder  # Callable[[HasValue[A], ReactiveValue[int]], Computed[A|T]]
+    return Animation(
+        start=frame,
+        end=frame,
+        start_value=value,
+        end_value=value,
+        animation_type=animation_type,
+    )