curryparty 0.2.3__tar.gz → 0.3.0__tar.gz

{curryparty-0.2.3 → curryparty-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: curryparty
-Version: 0.2.3
+Version: 0.3.0
 Summary: Python playground to learn lambda calculus
 Author: Antonin P
 Author-email: Antonin P <antonin.peronnet@telecom-paris.fr>
@@ -8,6 +8,11 @@ Requires-Dist: svg-py>=1.9.2
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 
+<p align="center">
+  <img src="https://github.com/rambip/curryparty/blob/main/logo.svg?raw=true" width="500px"/>
+</p>
+
+
 # Curry party
 
 `curryparty` is a library created to explore, visualize and teach lambda-calculus concepts.

{curryparty-0.2.3 → curryparty-0.3.0}/README.md

@@ -1,3 +1,8 @@
+<p align="center">
+  <img src="https://github.com/rambip/curryparty/blob/main/logo.svg?raw=true" width="500px"/>
+</p>
+
+
 # Curry party
 
 `curryparty` is a library created to explore, visualize and teach lambda-calculus concepts.

{curryparty-0.2.3 → curryparty-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "curryparty"
-version = "0.2.3"
+version = "0.3.0"
 description = "Python playground to learn lambda calculus"
 readme = "README.md"
 authors = [

{curryparty-0.2.3 → curryparty-0.3.0}/src/curryparty/__init__.py

@@ -17,12 +17,21 @@ from .display import (
     compute_svg_frame_init,
     compute_svg_frame_phase_a,
     compute_svg_frame_phase_b,
+    count_variables,
 )
-from .utils import ShapeAnim
+from .utils import ShapeAnim, ShapeAnimFrame
 
 __all__ = ["L", "V"]
 
 
+def log2(n):
+    if n <= 0:
+        raise ValueError(f"log2 of negative number {n}")
+    elif n == 1:
+        return 0
+    return 1 + log2(n // 2)
+
+
 class Term:
     def __init__(self, nodes: pl.DataFrame):
         assert nodes.schema == SCHEMA, (
@@ -58,7 +67,7 @@ class Term:
             if term is None:
                 break
 
-    def show_beta(self, x0=-10, width=30):
+    def show_beta(self, duration=7):
         """
         Generates an HTML representation that toggles visibility between
         a static state and a SMIL animation on hover using pure CSS.
@@ -71,37 +80,41 @@ class Term:
         new_nodes = beta_reduce(self.nodes, lamb, b)
         vars = find_variables(self.nodes, lamb)["id"]
         b_subtree = subtree(self.nodes, b)
-        height = compute_height(self.nodes) + 3
-        shapes: dict[int, ShapeAnim] = {}
+        height = min(compute_height(self.nodes), compute_height(new_nodes)) * 2
+        if count_variables(self.nodes) == 0:
+            return "no width"
+        raw_width = max(count_variables(self.nodes), count_variables(new_nodes))
+        width = 1 << (1 + log2(raw_width))
+        frame_data: list[ShapeAnimFrame] = []
         N_STEPS = 6
 
         for t in range(N_STEPS):
             if t == 0:
-                items = compute_svg_frame_init(self.nodes)
+                items = compute_svg_frame_init(self.nodes, t)
             elif t == 1 or t == 2:
-                items = compute_svg_frame_phase_a(self.nodes, lamb, b_subtree, vars)
+                items = compute_svg_frame_phase_a(self.nodes, lamb, b_subtree, vars, t)
             elif t == 3 or t == 4:
                 items = compute_svg_frame_phase_b(
-                    self.nodes, lamb, b_subtree, new_nodes
+                    self.nodes, lamb, b_subtree, new_nodes, t
                 )
             else:
-                items = compute_svg_frame_final(new_nodes)
-            for k, e, attributes in items:
-                if k not in shapes:
-                    shapes[k] = ShapeAnim(e)
-                shapes[k].append_frame(t, attributes.items())
+                items = compute_svg_frame_final(new_nodes, t)
+            frame_data.extend(items)
 
         figure_id = uuid.uuid4()
         box_id = f"lambda_box_{figure_id}".replace("-", "")
+        grouped = ShapeAnim.group_by_key(frame_data)
+        anims = [ShapeAnim.from_frames(frames, duration) for frames in grouped.values()]
+        anims.sort(key=lambda a: a.zindex)
         anim_elements = [
             x.to_element(N_STEPS, begin=f"{box_id}.click", reset=f"{box_id}.mouseover")
-            for x in shapes.values()
+            for x in anims
         ]
 
         anim_elements.append(
             Rect(
                 id=box_id,
-                x=str(x0),
+                x=f"{-width}",
                 y="0",
                 width="100%",
                 height="100%",
@@ -109,32 +122,43 @@ class Term:
             )
         )
 
+        # prefered size in pixels
+        H = height * 40
         anim_svg = SVG(
             xmlns="http://www.w3.org/2000/svg",
-            viewBox=f"{x0} 0 {width} {height}",
-            height=f"{35 * height}px",
+            viewBox=f"{-width} 0 {2 * width} {height}",
+            style=f"max-height:{H}px",
             elements=anim_elements,
         ).as_str()
 
         return Html(
-            f'<div><div style="margin:5px">click to animate, move away and back to reset</div>{anim_svg}</div>'
+            '<div style="width:100%">'
+            '<div style="margin-bottom:30px">'
+            "click to animate, move away and back to reset"
+            "</div>"
+            f"{anim_svg}"
+            "</div>"
         )
 
-    def _repr_html_(self, x0=-10, width=30):
-        frame = compute_svg_frame_init(self.nodes)
-        elements = []
+    def _repr_html_(self, x0=-10):
+        frame = sorted(compute_svg_frame_init(self.nodes), key=lambda x: x.zindex)
 
+        width = (1 << (1 + log2(count_variables(self.nodes)))) + 4
         height = compute_height(self.nodes) + 1
-        for _, e, attributes in frame:
-            for name, v in attributes.items():
-                e.__setattr__(name, v)
-            elements.append(e)
-        return SVG(
+
+        elements = [ShapeAnim.from_single_frame(x) for x in frame]
+
+        # prefered size in pixels
+        H = height * 40
+        W = width * 40
+
+        svg_element = SVG(
             xmlns="http://www.w3.org/2000/svg",
-            viewBox=f"{x0} 0 {width} {height}",  # type: ignore
-            height=f"{35 * height}px",  # type: ignore
+            viewBox=f"{-1} 0 {width} {height}",  # type: ignore
             elements=elements,
+            style=f"max-height:{H}px; margin-left: clamp(0px, calc(100% - {W}px), 100px)",
         ).as_str()
+        return f"<div>{svg_element}</div>"
 
 
 def offset_var(x: Union[int, str], offset: int) -> Union[int, str]:
@@ -156,26 +180,32 @@ class L:
         self.lambdas[name] = self.n
         return self
 
-    def _append_subtree_or_subexpression(self, t: Union[str, "L"]):
+    def _append_subtree_or_subexpression(self, t: Union[str, "L", Term]):
+        offset = self.n
         if isinstance(t, L):
-            offset = self.n
             for i, x in t.refs:
                 self.refs.append((offset + i, offset_var(t.lambdas.get(x, x), offset)))
 
             for i, x in t.args:
                 self.args.append((offset + i, offset + x))
             self.n += t.n
+        elif isinstance(t, Term):
+            for i, x in t.nodes.select("id", "ref").drop_nulls().iter_rows():
+                self.refs.append((offset + i, offset + x))
+            for i, x in t.nodes.select("id", "arg").drop_nulls().iter_rows():
+                self.args.append((offset + i, offset + x))
+            self.n += len(t.nodes)
         else:
             assert isinstance(t, str)
             self.refs.append((self.n, t))
             self.n += 1
 
-    def _(self, x: Union[str, "L"]) -> "L":
+    def _(self, x: Union[str, "L", Term]) -> "L":
         self.last_ = self.n
         self._append_subtree_or_subexpression(x)
         return self
 
-    def call(self, arg: Union[str, "L"]) -> "L":
+    def call(self, arg: Union[str, "L", Term]) -> "L":
         assert self.last_ is not None
         self.refs = [
             (i + 1, offset_var(x, 1)) if i >= self.last_ else (i, x)

{curryparty-0.2.3 → curryparty-0.3.0}/src/curryparty/display.py

@@ -3,7 +3,16 @@ from typing import Any, Iterable, Optional, Union
 import polars as pl
 import svg
 
-from .utils import Interval
+from .utils import Interval, ShapeAnimFrame
+
+
+def compute_height(nodes: pl.DataFrame):
+    _, y = compute_layout(nodes)
+    return max(interval[1] for interval in y.values() if interval) + 1
+
+
+def count_variables(nodes: pl.DataFrame):
+    return nodes["ref"].count()
 
 
 def compute_layout(
@@ -21,7 +30,7 @@ def compute_layout(
         else:
             y[child] = y[node].shift(1)
 
-    next_var_x = nodes.select(pl.col("ref").count()).item()
+    next_var_x = count_variables(nodes) - 1
 
     for node, ref, arg in (
         nodes.sort("id", descending=True).select("id", "ref", "arg").iter_rows()
@@ -38,10 +47,6 @@ def compute_layout(
             y[node] = y[child] | y[node]
     return x, y
 
-def compute_height(nodes: pl.DataFrame):
-    _, y = compute_layout(nodes)
-    return max(interval[1] for interval in y.values() if interval)
-
 
 def draw(
     x: dict[Union[int, tuple[int, int]], Interval],
@@ -50,42 +55,60 @@ def draw(
     ref: Optional[int],
     arg: Optional[int],
     key: Any,
+    idx: int,
     replaced=False,
     removed=False,
-) -> Iterable[tuple[Any, svg.Element, dict]]:
+    hide_arg=False,
+) -> Iterable[ShapeAnimFrame]:
     x_node = x[i_node]
     y_node = y[i_node]
-    if True:
-        if arg is not None or removed:
-            color = "transparent"
-        elif replaced or removed:
-            color = "green"
-        elif ref is not None:
-            color = "red"
-        else:
-            color = "blue"
+    if arg is not None or removed:
+        color = "transparent"
+    elif replaced or removed:
+        color = "green"
+    elif ref is not None:
+        color = "red"
+    else:
+        color = "blue"
 
-        stroke_width = 0.05
-        stroke = "gray"
-        if arg is not None:
-            stroke_width = 0.1
-            stroke = "orange"
+    r = svg.Rect(
+        height=0.8,
+        stroke_width=0.05,
+        stroke="gray",
+    )
+
+    yield ShapeAnimFrame(
+        element=r,
+        key=("r", key),
+        idx=idx,
+        attrs={
+            "x": 0.1 + x_node[0],
+            "y": 0.1 + y_node[0] + (1 if replaced else 0),
+            "width": 0.8 + x_node[1] - x_node[0],
+            "fill_opacity": 1 if arg is None else 0,
+            "fill": color,
+        },
+        zindex=0,
+    )
+    if arg is not None and not hide_arg:
         r = svg.Rect(
             height=0.8,
-            stroke_width=stroke_width,
-            stroke=stroke,
+            stroke_width=0.1,
+            stroke="orange",
         )
 
-        yield (
-            ("r", key),
-            r,
-            {
+        yield ShapeAnimFrame(
+            element=r,
+            key=("a", key),
+            idx=idx,
+            attrs={
                 "x": 0.1 + x_node[0],
                 "y": 0.1 + y_node[0],
                 "width": 0.8 + x_node[1] - x_node[0],
                 "fill_opacity": 1 if arg is None else 0,
                 "fill": color,
             },
+            zindex=1,
         )
 
     if ref is not None:
@@ -94,63 +117,65 @@ def draw(
             stroke_width=0.2,
             stroke="gray",
         )
-        yield (
-            ("l", key),
-            e,
-            {
+        yield ShapeAnimFrame(
+            element=e,
+            key=("l", key),
+            idx=idx,
+            attrs={
                 "x1": x_node[0] + 0.5,
-                "y1": y_node[0] + 0.1,
+                "y1": y_ref[0] + 0.9,
                 "x2": x_node[0] + 0.5,
-                "y2": y_ref[0] + 0.9,
+                "y2": y_node[0] + 0.1 + (1 if replaced else 0),
                 "stroke": "green" if replaced else "gray",
             },
+            zindex=2,
         )
 
     if arg is not None:
         x_arg = x[arg]
-        y_arg = y[arg]
         e1 = svg.Line(
             stroke="black",
             stroke_width=0.05,
         )
         e2 = svg.Circle(fill="black", r=0.1)
         if not removed:
-            yield (
-                ("b", key),
-                e1,
-                {
+            yield ShapeAnimFrame(
+                element=e1,
+                key=("b", key),
+                idx=idx,
+                attrs={
                     "x1": 0.5 + x_node[1],
                     "y1": 0.5 + y_node[0],
                     "x2": 0.5 + x_arg[0],
-                    "y2": 0.5 + y_arg[0],
+                    "y2": 0.5 + y_node[0],
                 },
+                zindex=3,
             )
-            yield (
-                ("c", key),
-                e2,
-                {
+            yield ShapeAnimFrame(
+                element=e2,
+                key=("c", key),
+                idx=idx,
+                attrs={
                     "cx": 0.5 + x_node[1],
                     "cy": 0.5 + y_node[0],
                 },
+                zindex=3,
             )
 
 
 def compute_svg_frame_init(
-    nodes: pl.DataFrame,
-) -> Iterable[tuple[Any, svg.Element, dict[str, Any]]]:
+    nodes: pl.DataFrame, idx: int = 0
+) -> Iterable[ShapeAnimFrame]:
     x, y = compute_layout(nodes)
     for target_id, ref, arg in (
         nodes.select("id", "ref", "arg").sort("id", descending=True).iter_rows()
     ):
-        yield from draw(x, y, target_id, ref, arg, target_id)
+        yield from draw(x, y, target_id, ref, arg, key=target_id, idx=idx)
 
 
 def compute_svg_frame_phase_a(
-    nodes: pl.DataFrame,
-    lamb: int,
-    b_subtree: pl.DataFrame,
-    vars: pl.Series,
-):
+    nodes: pl.DataFrame, lamb: int, b_subtree: pl.DataFrame, vars: pl.Series, idx: int
+) -> Iterable[ShapeAnimFrame]:
     redex = lamb - 1 if lamb is not None else None
     b_width = b_subtree.count()["ref"].item()
     x, y = compute_layout(nodes, lamb=lamb, replaced_var_width=b_width)
@@ -164,7 +189,8 @@ def compute_svg_frame_phase_a(
             target_id,
             ref,
             arg,
-            target_id,
+            key=target_id,
+            idx=idx,
             replaced=replaced,
             removed=(target_id == lamb or target_id == redex),
         )
@@ -173,7 +199,7 @@ def compute_svg_frame_phase_a(
         for minor, ref, arg in (
             b_subtree.select("id", "ref", "arg").sort("id", descending=True).iter_rows()
         ):
-            yield from draw(x, y, minor, ref, arg, key=(v, minor))
+            yield from draw(x, y, minor, ref, arg, key=(v, minor), idx=idx)
 
 
 def compute_svg_frame_phase_b(
@@ -181,7 +207,8 @@ def compute_svg_frame_phase_b(
     lamb: int,
     b_subtree: pl.DataFrame,
     new_nodes: pl.DataFrame,
-):
+    idx: int,
+) -> Iterable[ShapeAnimFrame]:
     b_width = b_subtree.count()["ref"].item()
     b = b_subtree["id"][0]
     x, y = compute_layout(nodes, lamb=lamb, replaced_var_width=b_width)
@@ -192,7 +219,7 @@ def compute_svg_frame_phase_b(
             v = bid["major"]
             minor = bid["minor"]
             delta_x = x[v][0] - b_x
-            delta_y = y[v][0] - b_y
+            delta_y = y[v][0] - b_y + 1
             x[(v, minor)] = x[minor].shift(delta_x)
             y[(v, minor)] = y[minor].shift(delta_y)
 
@@ -217,13 +244,21 @@ def compute_svg_frame_phase_b(
                 if bid_arg["major"] != bid_arg["minor"]
                 else bid_arg["minor"]
             )
-            if bid_arg["minor"] == b:
-                arg = bid_arg["major"]
         key = (v, minor) if minor != v else minor
-        yield from draw(x, y, key, ref, arg, key=key)
+        yield from draw(
+            x,
+            y,
+            key,
+            ref,
+            arg,
+            key=key,
+            idx=idx,
+        )
 
 
-def compute_svg_frame_final(reduced: pl.DataFrame):
+def compute_svg_frame_final(
+    reduced: pl.DataFrame, idx: int
+) -> Iterable[ShapeAnimFrame]:
     x, y = compute_layout(reduced)
     for target_id, bid, ref, arg in (
         reduced.select("id", "bid", "ref", "arg")
@@ -233,4 +268,4 @@ def compute_svg_frame_final(reduced: pl.DataFrame):
         minor = bid["minor"]
         major = bid["major"]
         key = (major, minor) if minor != major else minor
-        yield from draw(x, y, target_id, ref, arg, key)
+        yield from draw(x, y, target_id, ref, arg, key, idx=idx)

{curryparty-0.2.3 → curryparty-0.3.0}/src/curryparty/utils.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from datetime import timedelta
 from typing import Any, Iterable, Optional
 
@@ -33,30 +33,78 @@ class Interval:
             return Interval((self.values[0] + offset, self.values[1] + offset))
 
 
+@dataclass
+class ShapeAnimFrame:
+    element: Element
+    key: Any
+    idx: int
+    attrs: dict[str, Any]
+    zindex: int = 0
+
+    def apply_attributes(self):
+        for name, v in self.attrs.items():
+            self.element.__setattr__(name, v)
+
+
 @dataclass
 class ShapeAnim:
-    shape: Element
-    attributes: set[str]
-    values: dict[tuple[int, str], Any]
-    n: int
+    key: Any
+    element: Element
+    zindex: int
     duration: int
+    attributes: set[str] = field(default_factory=set)
+    values: dict[tuple[int, str], Any] = field(default_factory=dict)
+
+    @staticmethod
+    def from_single_frame(frame: ShapeAnimFrame) -> Element:
+        frame.apply_attributes()
+        return frame.element
+
+    @staticmethod
+    def from_frames(frames: list[ShapeAnimFrame], duration: int = 7) -> "ShapeAnim":
+        if not frames:
+            raise ValueError("frames list cannot be empty")
+
+        frames.sort(key=lambda f: f.idx)
+
+        zindex = frames[0].zindex
+        for f in frames[1:]:
+            if f.zindex != zindex:
+                raise ValueError(
+                    f"zindex mismatch for key {frames[0].key}: got {f.zindex}, expected {zindex}"
+                )
+
+        anim = ShapeAnim(
+            key=frames[0].key,
+            element=frames[0].element,
+            zindex=zindex,
+            duration=duration,
+        )
+
+        for f in frames:
+            for name, v in f.attrs.items():
+                anim.attributes.add(name)
+                anim.values[f.idx, name] = v
+
+        return anim
 
-    def __init__(
-        self,
-        shape: Element,
-        duration: int = 7,
-    ):
-        self.shape = shape
-        self.attributes = set()
-        self.values = {}
-        self.duration = duration
+    @staticmethod
+    def group_by_key(
+        frames: Iterable[ShapeAnimFrame],
+    ) -> dict[Any, list[ShapeAnimFrame]]:
+        groups: dict[Any, list[ShapeAnimFrame]] = {}
+        for frame in frames:
+            if frame.key not in groups:
+                groups[frame.key] = []
+            groups[frame.key].append(frame)
+        return groups
 
     def append_frame(self, i: int, attributes: Iterable[tuple[str, Any]]):
         for name, v in attributes:
             self.attributes.add(name)
             self.values[i, name] = v
 
-    def to_element(self, n: int, begin: str, reset: str):
+    def to_element(self, n: int, begin: str, reset: str) -> Element:
         elements = []
 
         visible = [
@@ -74,7 +122,7 @@ class ShapeAnim:
             for i in range(n):
                 if (i, name) not in self.values:
                     self.values[i, name] = non_nulls[0]
-            self.shape.__setattr__(name, non_nulls[0])
+            self.element.__setattr__(name, non_nulls[0])
 
             elements.append(
                 Animate(
@@ -113,7 +161,6 @@ class ShapeAnim:
             )
         )
 
-        assert not self.shape.elements
-        self.shape
-        self.shape.elements = elements
-        return self.shape
+        assert not self.element.elements
+        self.element.elements = elements
+        return self.element