excanim 0.1.0__tar.gz

excanim-0.1.0/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.3
+Name: excanim
+Version: 0.1.0
+Summary: Manim-style API for Excalidraw drawings and animations
+Author: Dheemanth Manur
+Author-email: Dheemanth Manur <dheemanthmanur72@gmail.com>
+Requires-Dist: imageio>=2.37.3
+Requires-Dist: imageio-ffmpeg>=0.6.0
+Requires-Dist: playwright>=1.58.0
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# excanim
+
+Manim-style Python API for Excalidraw drawings and animations.
+
+## Install
+
+```bash
+pip install excanim
+playwright install chromium
+```
+
+**Requirements:** Python 3.12+
+
+## Examples
+
+See [`examples/`](examples/) — architecture diagram, bouncing ball, physics simulation, matrix multiplication.
+
+## How it works
+
+Python builds Excalidraw element JSON, renders it through `@excalidraw/excalidraw` in headless Chromium via Playwright, outputs SVG/PNG/MP4.

excanim-0.1.0/README.md

@@ -0,0 +1,20 @@
+# excanim
+
+Manim-style Python API for Excalidraw drawings and animations.
+
+## Install
+
+```bash
+pip install excanim
+playwright install chromium
+```
+
+**Requirements:** Python 3.12+
+
+## Examples
+
+See [`examples/`](examples/) — architecture diagram, bouncing ball, physics simulation, matrix multiplication.
+
+## How it works
+
+Python builds Excalidraw element JSON, renders it through `@excalidraw/excalidraw` in headless Chromium via Playwright, outputs SVG/PNG/MP4.

excanim-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "excanim"
+version = "0.1.0"
+description = "Manim-style API for Excalidraw drawings and animations"
+readme = "README.md"
+authors = [
+    { name = "Dheemanth Manur", email = "dheemanthmanur72@gmail.com" }
+]
+requires-python = ">=3.12"
+dependencies = [
+    "imageio>=2.37.3",
+    "imageio-ffmpeg>=0.6.0",
+    "playwright>=1.58.0",
+]
+
+[build-system]
+requires = ["uv_build>=0.10.11,<0.11.0"]
+build-backend = "uv_build"
+
+[tool.uv-build]
+data-files = {"excanim/bridge" = ["src/excanim/bridge/*"]}

excanim-0.1.0/src/excanim/__init__.py

@@ -0,0 +1,6 @@
+from excanim.scene import Scene
+from excanim.elements.shapes import Rect, Ellipse, Diamond
+from excanim.elements.lines import Line, Arrow
+from excanim.elements.text import Text
+
+__all__ = ["Scene", "Rect", "Ellipse", "Diamond", "Line", "Arrow", "Text"]

excanim-0.1.0/src/excanim/anim/__init__.py

@@ -0,0 +1,19 @@
+from excanim.anim.base import Animation, KeyFrame
+from excanim.anim.easing import (
+    Linear, EaseIn, EaseOut, EaseInOut,
+    EaseInCubic, EaseOutCubic, EaseInOutCubic,
+    BounceIn, BounceOut,
+)
+from excanim.anim.fade import FadeIn, FadeOut
+from excanim.anim.transform import MoveTo, ScaleTo
+from excanim.anim.create import Create, Write
+
+__all__ = [
+    "Animation", "KeyFrame",
+    "Linear", "EaseIn", "EaseOut", "EaseInOut",
+    "EaseInCubic", "EaseOutCubic", "EaseInOutCubic",
+    "BounceIn", "BounceOut",
+    "FadeIn", "FadeOut",
+    "MoveTo", "ScaleTo",
+    "Create", "Write",
+]

excanim-0.1.0/src/excanim/anim/base.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from excanim.anim.easing import EasingFunc, linear
+from excanim.elements.base import Element
+
+
+@dataclass
+class KeyFrame:
+    element_id: str
+    prop: str  # "opacity", "x", "y", "width", "height"
+    t_start: float
+    t_end: float
+    val_start: float
+    val_end: float
+    easing: EasingFunc = field(default=linear, repr=False)
+
+    def interpolate(self, t: float) -> float:
+        if t <= self.t_start:
+            return self.val_start
+        if t >= self.t_end:
+            return self.val_end
+        duration = self.t_end - self.t_start
+        if duration == 0:
+            return self.val_end
+        progress = (t - self.t_start) / duration
+        eased = self.easing(progress)
+        return self.val_start + (self.val_end - self.val_start) * eased
+
+
+class Animation:
+    def __init__(self, target: Element, duration: float = 1.0, easing: EasingFunc = linear):
+        self.target = target
+        self.duration = duration
+        self.easing = easing
+
+    def resolve(self, t_start: float) -> list[KeyFrame]:
+        raise NotImplementedError

excanim-0.1.0/src/excanim/anim/create.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from excanim.anim.base import Animation, KeyFrame
+from excanim.anim.easing import EasingFunc, linear
+from excanim.elements.base import Element
+
+
+class Create(Animation):
+    """Animate an element appearing with a stroke draw-on effect.
+
+    For now, implemented as a FadeIn since true stroke-dashoffset
+    animation requires SVG post-processing. Can be upgraded later.
+    """
+
+    def __init__(self, target: Element, duration: float = 1.0, easing: EasingFunc = linear):
+        super().__init__(target, duration, easing)
+
+    def resolve(self, t_start: float) -> list[KeyFrame]:
+        return [
+            KeyFrame(
+                element_id=self.target.id,
+                prop="opacity",
+                t_start=t_start,
+                t_end=t_start + self.duration,
+                val_start=0,
+                val_end=self.target.opacity,
+                easing=self.easing,
+            )
+        ]
+
+
+class Write(Animation):
+    """Animate text appearing with a typewriter-like effect.
+
+    For now, implemented as FadeIn. True character-by-character
+    animation would require per-frame text content changes.
+    """
+
+    def __init__(self, target: Element, duration: float = 1.0, easing: EasingFunc = linear):
+        super().__init__(target, duration, easing)
+
+    def resolve(self, t_start: float) -> list[KeyFrame]:
+        return [
+            KeyFrame(
+                element_id=self.target.id,
+                prop="opacity",
+                t_start=t_start,
+                t_end=t_start + self.duration,
+                val_start=0,
+                val_end=self.target.opacity,
+                easing=self.easing,
+            )
+        ]

excanim-0.1.0/src/excanim/anim/easing.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import math
+from typing import Callable
+
+EasingFunc = Callable[[float], float]
+
+
+def linear(t: float) -> float:
+    return t
+
+
+def ease_in(t: float) -> float:
+    return t * t
+
+
+def ease_out(t: float) -> float:
+    return 1 - (1 - t) * (1 - t)
+
+
+def ease_in_out(t: float) -> float:
+    if t < 0.5:
+        return 2 * t * t
+    return 1 - (-2 * t + 2) ** 2 / 2
+
+
+def ease_in_cubic(t: float) -> float:
+    return t * t * t
+
+
+def ease_out_cubic(t: float) -> float:
+    return 1 - (1 - t) ** 3
+
+
+def ease_in_out_cubic(t: float) -> float:
+    if t < 0.5:
+        return 4 * t * t * t
+    return 1 - (-2 * t + 2) ** 3 / 2
+
+
+def bounce_out(t: float) -> float:
+    n1, d1 = 7.5625, 2.75
+    if t < 1 / d1:
+        return n1 * t * t
+    elif t < 2 / d1:
+        t -= 1.5 / d1
+        return n1 * t * t + 0.75
+    elif t < 2.5 / d1:
+        t -= 2.25 / d1
+        return n1 * t * t + 0.9375
+    else:
+        t -= 2.625 / d1
+        return n1 * t * t + 0.984375
+
+
+def bounce_in(t: float) -> float:
+    return 1 - bounce_out(1 - t)
+
+
+def ease_out_quart(t: float) -> float:
+    return 1 - (1 - t) ** 4
+
+
+def ease_in_out_quart(t: float) -> float:
+    if t < 0.5:
+        return 8 * t * t * t * t
+    return 1 - (-2 * t + 2) ** 4 / 2
+
+
+def spring(t: float) -> float:
+    """Apple-style spring easing — slight overshoot then settle."""
+    return 1 - math.cos(t * math.pi * 0.5) * math.exp(-t * 3.5) * (1 - t)
+
+
+# Convenience aliases
+Linear = linear
+EaseIn = ease_in
+EaseOut = ease_out
+EaseInOut = ease_in_out
+EaseInCubic = ease_in_cubic
+EaseOutCubic = ease_out_cubic
+EaseInOutCubic = ease_in_out_cubic
+BounceIn = bounce_in
+BounceOut = bounce_out

excanim-0.1.0/src/excanim/anim/fade.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from excanim.anim.base import Animation, KeyFrame
+from excanim.anim.easing import EasingFunc, linear
+from excanim.elements.base import Element
+
+
+class FadeIn(Animation):
+    def __init__(self, target: Element, duration: float = 1.0, easing: EasingFunc = linear):
+        super().__init__(target, duration, easing)
+
+    def resolve(self, t_start: float) -> list[KeyFrame]:
+        return [
+            KeyFrame(
+                element_id=self.target.id,
+                prop="opacity",
+                t_start=t_start,
+                t_end=t_start + self.duration,
+                val_start=0,
+                val_end=self.target.opacity,
+                easing=self.easing,
+            )
+        ]
+
+
+class FadeOut(Animation):
+    def __init__(self, target: Element, duration: float = 1.0, easing: EasingFunc = linear):
+        super().__init__(target, duration, easing)
+
+    def resolve(self, t_start: float) -> list[KeyFrame]:
+        return [
+            KeyFrame(
+                element_id=self.target.id,
+                prop="opacity",
+                t_start=t_start,
+                t_end=t_start + self.duration,
+                val_start=self.target.opacity,
+                val_end=0,
+                easing=self.easing,
+            )
+        ]

excanim-0.1.0/src/excanim/anim/transform.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from excanim.anim.base import Animation, KeyFrame
+from excanim.anim.easing import EasingFunc, linear
+from excanim.elements.base import Element
+
+
+class MoveTo(Animation):
+    def __init__(
+        self,
+        target: Element,
+        x: float | None = None,
+        y: float | None = None,
+        duration: float = 1.0,
+        easing: EasingFunc = linear,
+    ):
+        super().__init__(target, duration, easing)
+        self._x = x
+        self._y = y
+
+    def resolve(self, t_start: float) -> list[KeyFrame]:
+        kfs = []
+        if self._x is not None:
+            kfs.append(
+                KeyFrame(
+                    element_id=self.target.id,
+                    prop="x",
+                    t_start=t_start,
+                    t_end=t_start + self.duration,
+                    val_start=self.target.x,
+                    val_end=self._x,
+                    easing=self.easing,
+                )
+            )
+        if self._y is not None:
+            kfs.append(
+                KeyFrame(
+                    element_id=self.target.id,
+                    prop="y",
+                    t_start=t_start,
+                    t_end=t_start + self.duration,
+                    val_start=self.target.y,
+                    val_end=self._y,
+                    easing=self.easing,
+                )
+            )
+        return kfs
+
+
+class ScaleTo(Animation):
+    def __init__(
+        self,
+        target: Element,
+        sx: float = 1.0,
+        sy: float = 1.0,
+        duration: float = 1.0,
+        easing: EasingFunc = linear,
+    ):
+        super().__init__(target, duration, easing)
+        self._sx = sx
+        self._sy = sy
+
+    def resolve(self, t_start: float) -> list[KeyFrame]:
+        # Scale relative to ORIGINAL base size (not current animated size)
+        # This prevents compounding: ScaleTo(sx=1.0) always returns to original
+        cx = self.target.x + self.target.width / 2
+        cy = self.target.y + self.target.height / 2
+        new_w = self.target._base_width * self._sx
+        new_h = self.target._base_height * self._sy
+        new_x = cx - new_w / 2
+        new_y = cy - new_h / 2
+
+        return [
+            KeyFrame(
+                element_id=self.target.id,
+                prop="width",
+                t_start=t_start,
+                t_end=t_start + self.duration,
+                val_start=self.target.width,
+                val_end=new_w,
+                easing=self.easing,
+            ),
+            KeyFrame(
+                element_id=self.target.id,
+                prop="height",
+                t_start=t_start,
+                t_end=t_start + self.duration,
+                val_start=self.target.height,
+                val_end=new_h,
+                easing=self.easing,
+            ),
+            KeyFrame(
+                element_id=self.target.id,
+                prop="x",
+                t_start=t_start,
+                t_end=t_start + self.duration,
+                val_start=self.target.x,
+                val_end=new_x,
+                easing=self.easing,
+            ),
+            KeyFrame(
+                element_id=self.target.id,
+                prop="y",
+                t_start=t_start,
+                t_end=t_start + self.duration,
+                val_start=self.target.y,
+                val_end=new_y,
+                easing=self.easing,
+            ),
+        ]