glideshow 0.1.2__py3-none-any.whl

glideshow/pptx_export.py

@@ -0,0 +1,207 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = ["python-pptx"]
+# ///
+"""deck.html → .pptx, best effort: slide backgrounds, text boxes (paragraphs, size, bold / italic, colour, alignment),
+pictures, tables, the common shapes with their fill and outline, straight lines, and speaker notes. Videos and web
+embeds are left out.
+
+    uv run glideshow/pptx_export.py DECK/deck.html OUT.pptx
+
+The server runs this for File → Download → PowerPoint; python-pptx stays out of the server itself.
+"""
+import re, sys
+from html.parser import HTMLParser
+from pathlib import Path
+
+from pptx import Presentation
+from pptx.dml.color import RGBColor
+from pptx.enum.shapes import MSO_CONNECTOR, MSO_SHAPE
+from pptx.enum.text import PP_ALIGN
+from pptx.util import Emu, Pt
+
+EMU_PX = 914400 * 10 / 1920   # the 1920 px canvas is 10 in wide
+PX_PT = 192 / 72
+SHAPES = {"rect": "RECTANGLE", "roundrect": "ROUNDED_RECTANGLE", "ellipse": "OVAL", "triangle": "ISOSCELES_TRIANGLE", "diamond": "DIAMOND",
+          "parallelogram": "PARALLELOGRAM", "trapezoid": "TRAPEZOID", "pentagon": "REGULAR_PENTAGON", "hexagon": "HEXAGON", "octagon": "OCTAGON",
+          "star": "STAR_5_POINT", "cloud": "CLOUD", "arrow": "RIGHT_ARROW", "leftarrow": "LEFT_ARROW", "uparrow": "UP_ARROW", "downarrow": "DOWN_ARROW",
+          "leftrightarrow": "LEFT_RIGHT_ARROW", "chevron": "CHEVRON", "callout": "RECTANGULAR_CALLOUT", "roundcallout": "ROUNDED_RECTANGULAR_CALLOUT",
+          "cross": "CROSS", "heart": "HEART", "donut": "DONUT", "can": "CAN", "cube": "CUBE", "homeplate": "PENTAGON", "rttriangle": "RIGHT_TRIANGLE"}
+BLOCK = {"div", "p", "li", "h1", "h2", "h3", "pre", "tr"}
+# every other shape: its OOXML preset name from shapes.js' PRESET_OF table, which PowerPoint knows natively
+_js = (next(d for d in (Path(__file__).resolve().parent / "editor", Path(__file__).resolve().parent.parent / "editor") if d.is_dir()) / "deck" / "shapes.js").read_text()
+PRESET_OF = dict(re.findall(r"['\"]?([\w-]+)['\"]?:\s*'(\w+)'", _js[_js.index("PRESET_OF = {"):_js.index("};", _js.index("PRESET_OF = {"))]))
+
+
+def mso(shape_name):
+    if shape_name in SHAPES: return getattr(MSO_SHAPE, SHAPES[shape_name])
+    try: return MSO_SHAPE.from_xml(PRESET_OF.get(shape_name, ""))
+    except (ValueError, KeyError): return None
+
+
+class Node:
+    def __init__(self, tag, attrs, parent=None):
+        self.tag, self.attrs, self.parent, self.kids = tag, dict(attrs), parent, []
+
+    def cls(self):
+        return self.attrs.get("class", "").split()
+
+    def find_all(self, pred):
+        for k in self.kids:
+            if isinstance(k, Node):
+                if pred(k): yield k
+                yield from k.find_all(pred)
+
+    def text(self):
+        return "".join(k if isinstance(k, str) else k.text() for k in self.kids)
+
+
+class Tree(HTMLParser):
+    VOID = {"img", "br", "meta", "link", "input", "hr", "source"}
+
+    def __init__(self):
+        super().__init__(convert_charrefs=True)
+        self.root = self.cur = Node("root", {})
+
+    def handle_starttag(self, tag, attrs):
+        n = Node(tag, attrs, self.cur); self.cur.kids.append(n)
+        if tag not in self.VOID: self.cur = n
+
+    def handle_endtag(self, tag):
+        n = self.cur
+        while n is not self.root and n.tag != tag: n = n.parent
+        if n is not self.root: self.cur = n.parent
+
+    def handle_data(self, data):
+        self.cur.kids.append(data)
+
+
+def style(n):
+    return {k.strip(): v.strip() for k, v in (d.split(":", 1) for d in n.attrs.get("style", "").split(";") if ":" in d)}
+
+
+def px(v, default=0.0):
+    m = re.match(r"(-?[\d.]+)px", v or "")
+    return float(m.group(1)) if m else default
+
+
+def rgb(v):
+    m = re.fullmatch(r"#([0-9a-fA-F]{6})(?:[0-9a-fA-F]{2})?", (v or "").strip()) or re.fullmatch(r"#([0-9a-fA-F]{3})", (v or "").strip())
+    if not m: return None
+    h = m.group(1)
+    return RGBColor.from_string(h if len(h) == 6 else "".join(c * 2 for c in h))
+
+
+def paragraphs(content):
+    """[(text, block style)] — one per block child / list item / <br>, inline text joined."""
+    out, line = [], []
+    def walk(n, inherited):
+        for k in n.kids:
+            if isinstance(k, str): line.append(k)
+            elif k.tag == "br": flush(inherited)
+            elif k.tag in ("ul", "ol"): walk(k, inherited)
+            elif k.tag in BLOCK: flush(inherited); walk(k, {**inherited, **style(k)}); flush({**inherited, **style(k)}, k.tag == "li")
+            elif k.tag not in ("svg", "aside", "script", "style"): walk(k, inherited)
+    def flush(st, bullet=False):
+        t = re.sub(r"\s+", " ", "".join(line)).strip()
+        if t: out.append((("• " if bullet else "") + t, st))
+        line.clear()
+    walk(content, {}); flush({})
+    return out
+
+
+def add_text(shape, content, box_style):
+    st = style(content)
+    tf = shape.text_frame; tf.word_wrap = True
+    paras = paragraphs(content)
+    if not paras: return
+    tf.text = ""
+    for i, (t, pst) in enumerate(paras):
+        p = tf.paragraphs[0] if i == 0 else tf.add_paragraph()
+        r = p.add_run(); r.text = t
+        size = px(pst.get("font-size") or st.get("font-size"), 37.33)
+        r.font.size = Pt(round(size / PX_PT, 1))
+        r.font.bold = (pst.get("font-weight") or st.get("font-weight")) in ("bold", "700")
+        r.font.italic = (pst.get("font-style") or st.get("font-style")) == "italic"
+        c = rgb(pst.get("color") or st.get("color"))
+        if c: r.font.color.rgb = c
+        fam = (st.get("font-family") or "").split(",")[0].strip("'\" ")
+        if fam: r.font.name = fam
+        p.alignment = {"center": PP_ALIGN.CENTER, "right": PP_ALIGN.RIGHT, "justify": PP_ALIGN.JUSTIFY}.get(pst.get("text-align") or st.get("text-align") or "", PP_ALIGN.LEFT if not box_style.get("shape") else PP_ALIGN.CENTER)
+
+
+def export(deck: Path, out: Path):
+    t = Tree(); t.feed(deck.read_text()); root = t.root
+    slides_el = next(root.find_all(lambda n: n.tag == "div" and "slides" in n.cls()))
+    m = re.match(r"(\d+)x(\d+)$", slides_el.attrs.get("data-size", ""))
+    W, H = (int(m.group(1)), int(m.group(2))) if m else (1920, 1080)
+    prs = Presentation(); prs.slide_width, prs.slide_height = Emu(int(W * EMU_PX)), Emu(int(H * EMU_PX))
+    blank = prs.slide_layouts[6]
+    sections = [s for top in slides_el.kids if isinstance(top, Node) and top.tag == "section"
+                for s in ([k for k in top.kids if isinstance(k, Node) and k.tag == "section"] or [top])]
+    for sec in sections:
+        slide = prs.slides.add_slide(blank)
+        bg = rgb(sec.attrs.get("data-background-color"))
+        if bg: slide.background.fill.solid(); slide.background.fill.fore_color.rgb = bg
+        for box in [k for k in sec.kids if isinstance(k, Node) and "box" in k.cls()]:
+            add_box(slide, box, deck.parent, 0, 0)
+        notes = [k for k in sec.kids if isinstance(k, Node) and k.tag == "aside" and "notes" in k.cls()]
+        if notes: slide.notes_slide.notes_text_frame.text = notes[0].text().strip()
+    prs.save(out)
+
+
+def add_box(slide, box, base, ox, oy):
+    st, a = style(box), box.attrs
+    x, y, w, h = ox + px(st.get("left")), oy + px(st.get("top")), px(st.get("width"), 1), px(st.get("height"), 1)
+    E = lambda v: Emu(int(v * EMU_PX))
+    content = next((k for k in box.kids if isinstance(k, Node) and "content" in k.cls()), None)
+    shape_name, cls = a.get("data-shape", ""), box.cls()
+    if "group" in cls:
+        for k in box.kids:
+            if isinstance(k, Node) and "box" in k.cls(): add_box(slide, k, base, x, y)
+        return
+    if "image" in cls:
+        img = next((n for n in box.find_all(lambda n: n.tag == "img")), None)
+        src = img and img.attrs.get("src", "")
+        if src and not src.startswith(("data:", "http")) and (base / src).exists():
+            slide.shapes.add_picture(str(base / src), E(x), E(y), E(w), E(h))
+        return
+    if "video" in cls or "embed" in cls:
+        return   # PowerPoint can't take these from HTML; left out
+    if "table" in cls:
+        rows = [r for r in box.find_all(lambda n: n.tag == "tr")]
+        cols = max((len([c for c in r.kids if isinstance(c, Node) and c.tag in ("td", "th")]) for r in rows), default=0)
+        if rows and cols:
+            tb = slide.shapes.add_table(len(rows), cols, E(x), E(y), E(w), E(h)).table
+            size = px(style(content).get("font-size") if content else None, 37.33)
+            for i, r in enumerate(rows):
+                for j, c in enumerate([c for c in r.kids if isinstance(c, Node) and c.tag in ("td", "th")]):
+                    cell = tb.cell(i, j); cell.text = re.sub(r"\s+", " ", c.text()).strip()
+                    for p in cell.text_frame.paragraphs:
+                        for run in p.runs: run.font.size = Pt(round(size / PX_PT, 1))
+        return
+    sw = px(st.get("--sw"), 4)
+    if shape_name in ("line", "arrowline", "elbow", "curve"):
+        up = a.get("data-dir") == "up"
+        ln = slide.shapes.add_connector(MSO_CONNECTOR.STRAIGHT, E(x), E(y + h if up else y), E(x + w), E(y if up else y + h))
+        ln.line.width = Emu(int(sw * EMU_PX)); c = rgb(st.get("--stroke"))
+        if c: ln.line.color.rgb = c
+        return
+    if shape_name and mso(shape_name) is not None:
+        sh = slide.shapes.add_shape(mso(shape_name), E(x), E(y), E(w), E(h))
+        f, s = rgb(st.get("--fill")), rgb(st.get("--stroke"))
+        if f: sh.fill.solid(); sh.fill.fore_color.rgb = f
+        else: sh.fill.background()
+        if s: sh.line.color.rgb = s; sh.line.width = Emu(int(sw * EMU_PX))
+        else: sh.line.fill.background()
+    elif shape_name:
+        return   # a shape PowerPoint export doesn't know yet
+    else:
+        sh = slide.shapes.add_textbox(E(x), E(y), E(w), E(h))
+        f = rgb(st.get("--fill"))
+        if f: sh.fill.solid(); sh.fill.fore_color.rgb = f
+    if content is not None: add_text(sh, content, {"shape": shape_name})
+
+
+if __name__ == "__main__":
+    export(Path(sys.argv[1]), Path(sys.argv[2]))

glideshow/pptx_import.py

@@ -0,0 +1,115 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = ["python-pptx"]
+# ///
+"""A .pptx → deck sections, best effort: slide backgrounds, text boxes and placeholders (paragraphs with size, bold /
+italic, colour, alignment), pictures (saved into the deck's assets/), tables, shapes PowerPoint and shapes.js share
+(by OOXML preset name), straight lines and speaker notes. Groups are flattened. Prints JSON: {"slides": [html, …]}.
+
+    uv run glideshow/pptx_import.py IN.pptx DECK/assets
+"""
+import hashlib, html, json, re, sys
+from pathlib import Path
+
+from pptx import Presentation
+from pptx.enum.shapes import MSO_SHAPE_TYPE
+from pptx.enum.text import PP_ALIGN
+
+_js = (next(d for d in (Path(__file__).resolve().parent / "editor", Path(__file__).resolve().parent.parent / "editor") if d.is_dir()) / "deck" / "shapes.js").read_text()
+_po = _js[_js.index("PRESET_OF = {"):_js.index("};", _js.index("PRESET_OF = {"))]
+OURS = {prst: name for name, prst in re.findall(r"['\"]?([\w-]+)['\"]?:\s*'(\w+)'", _po)}   # OOXML preset → our data-shape
+OURS.update({"rect": "rect", "roundRect": "roundrect", "ellipse": "ellipse"})
+ALIGN = {PP_ALIGN.CENTER: "center", PP_ALIGN.RIGHT: "right", PP_ALIGN.JUSTIFY: "justify"}
+
+
+def hexcolor(fmt):
+    try:
+        return "#" + str(fmt.rgb) if fmt.type is not None and fmt.rgb is not None else None
+    except (AttributeError, KeyError, TypeError, ValueError):
+        return None
+
+
+def text_html(tf, k):
+    paras, sizes = [], []
+    for p in tf.paragraphs:
+        runs = []
+        for r in p.runs:
+            st = []
+            if r.font.size: st.append(f"font-size: {round(r.font.size.pt * 192 / 72, 2)}px"); sizes.append(r.font.size.pt)
+            if r.font.bold: st.append("font-weight: bold")
+            if r.font.italic: st.append("font-style: italic")
+            c = hexcolor(r.font.color) if r.font.color and r.font.color.type is not None else None
+            if c: st.append(f"color: {c}")
+            t = html.escape(r.text)
+            runs.append(f'<span style="{"; ".join(st)}">{t}</span>' if st else t)
+        align = ALIGN.get(p.alignment)
+        st = f' style="text-align: {align}"' if align else ''   # (no quotes or backslashes inside an f-string's braces before Python 3.12)
+        paras.append(f'<div{st}>{"".join(runs) or "<br>"}</div>')
+    return "".join(paras)
+
+
+def walk(shapes, k, assets, out):
+    for sh in shapes:
+        if sh.shape_type == MSO_SHAPE_TYPE.GROUP:
+            walk(sh.shapes, k, assets, out); continue
+        if sh.left is None or sh.width is None:
+            continue
+        x, y, w, h = (round(v * k, 1) for v in (sh.left, sh.top, sh.width, sh.height))
+        pos = f"left: {x}px; top: {y}px; width: {w}px; height: {h}px;"
+        if sh.shape_type == MSO_SHAPE_TYPE.PICTURE:
+            blob = sh.image.blob
+            name = f"{hashlib.sha1(blob).hexdigest()[:12]}.{sh.image.ext}"
+            (assets / name).write_bytes(blob)
+            out.append(f'<div class="box image" style="{pos}"><div class="content"><img src="assets/{name}" alt=""></div></div>'); continue
+        if sh.has_table if hasattr(sh, "has_table") else False:
+            rows = "".join("<tr>" + "".join(f"<td>{html.escape(c.text)}</td>" for c in r.cells) + "</tr>" for r in sh.table.rows)
+            out.append(f'<div class="box table" data-valign="top" style="{pos}"><div class="content" style="padding: 0px;"><table>{rows}</table></div></div>'); continue
+        if sh.shape_type in (MSO_SHAPE_TYPE.LINE,) or sh.__class__.__name__ == "Connector":
+            col = hexcolor(sh.line.color) if sh.line.fill.type is not None else None
+            sw = round(sh.line.width * k, 2) if sh.line.width else 2.67
+            up = sh.begin_y > sh.end_y if hasattr(sh, "begin_y") else False
+            updir = ' data-dir="up"' if up else ''
+            out.append(f'<div class="box" data-shape="line"{updir} style="{pos} --sw: {sw}px;{f" --stroke: {col};" if col else ""}"><div class="content"></div></div>'); continue
+        attrs, style = "", pos
+        if sh.shape_type == MSO_SHAPE_TYPE.AUTO_SHAPE:
+            try: prst = sh.auto_shape_type and sh.auto_shape_type.xml_value
+            except (NotImplementedError, ValueError, AttributeError): prst = None
+            name = OURS.get(prst or "", "rect")
+            attrs = f' data-shape="{name}"'
+            try:
+                if sh.fill.type is not None: style += f" --fill: {hexcolor(sh.fill.fore_color) or '#eeeeee'};"
+                else: style += " --fill: transparent;"
+            except (TypeError, AttributeError): pass
+            try:
+                if sh.line.fill.type is not None:
+                    c = hexcolor(sh.line.color)
+                    style += f" --stroke: {c or '#595959'}; --sw: {round((sh.line.width or 12700) * k, 2)}px;"
+            except (TypeError, AttributeError): pass
+        inner = text_html(sh.text_frame, k) if sh.has_text_frame and sh.text_frame.text.strip() else ""
+        if not attrs and not inner:
+            continue
+        valign = "" if attrs else ' data-valign="top"'   # text boxes hang from the top; shapes centre their text, as in both apps
+        left = '' if attrs else ' style="text-align: left;"'
+        out.append(f'<div class="box"{attrs}{valign} style="{style}"><div class="content"{left}>{inner}</div></div>')
+
+
+def convert(src: Path, assets: Path):
+    prs = Presentation(src)
+    assets.mkdir(parents=True, exist_ok=True)
+    k = 1920 / prs.slide_width   # px per EMU
+    slides = []
+    for s in prs.slides:
+        bg = ""
+        try:
+            if s.background.fill.type is not None: bg = hexcolor(s.background.fill.fore_color) or ""
+        except (TypeError, AttributeError): pass
+        out = []
+        walk(s.shapes, k, assets, out)
+        if s.has_notes_slide and s.notes_slide.notes_text_frame.text.strip():
+            out.append(f'<aside class="notes">{html.escape(s.notes_slide.notes_text_frame.text.strip())}</aside>')
+        slides.append(f'<section data-background-color="{bg or "#ffffff"}">\n  ' + "\n  ".join(out) + "\n</section>")
+    return {"slides": slides, "size": [1920, round(prs.slide_height * k)]}
+
+
+if __name__ == "__main__":
+    print(json.dumps(convert(Path(sys.argv[1]), Path(sys.argv[2]))))

glideshow/publish.py

@@ -0,0 +1,106 @@
+"""`glideshow publish` / Share: a link to a deck at Glideshow (glideshow.org/p/<owner>/<slug>/), docs/self-hosting.md.
+
+The library's published.json says which decks are shared, under which link, as of which commit, and with whom:
+    "Lab/talk": {"slug": "talk-k3x9…", "rev": "<commit>", "access": "link" | "people", "people": ["a@b.org", "@harvard.edu", "octocat"],
+                 "expires": "2026-12-31", "title": …, "url": …}
+Sharing is that entry, committed and pushed with the library; glideshow.org reads it from the library's GitHub repo
+(with the Glideshow app installed on it) and serves the deck's latest pushed version (`rev` only records the version it
+was shared at). So the library must be on GitHub (`glideshow init-remote`), and the link follows each save once it's pushed. No index of decks exists, and robots are told
+to stay out, so a deck is reachable only by its link."""
+
+import json, secrets
+from pathlib import Path
+
+from .decks import HOME, deck_title
+from .history import commit_library, commit_now, git, github_url
+
+CONFIG = Path.home() / ".glideshow" / "config.json"
+LEDGER = HOME / "published.json"
+SITE = "https://glideshow.org"
+
+
+def config() -> dict:
+    try: return json.loads(CONFIG.read_text())
+    except (OSError, ValueError): return {}
+
+
+def ledger() -> dict:
+    try: return json.loads(LEDGER.read_text())
+    except (OSError, ValueError): return {}
+
+
+def _rel(deck: Path) -> str:
+    if HOME.resolve() not in deck.resolve().parents: raise SystemExit(f"Only decks in your library ({HOME}) can be shared; move this one there first.")
+    return deck.resolve().relative_to(HOME.resolve()).as_posix()
+
+
+def _owner() -> str:
+    """Whose library the link names: the GitHub owner of the library's repo (config "share_owner" overrides)."""
+    if config().get("share_owner"): return config()["share_owner"].lower()
+    web = github_url(HOME)
+    if not web: raise SystemExit("Sharing needs the library on GitHub (`glideshow init-remote`), with the Glideshow app installed on that repo.")
+    return web.rstrip("/").split("/")[-2].lower()
+
+
+def _people(v) -> list:
+    items = v if isinstance(v, list) else str(v or "").replace(";", ",").replace("\n", ",").replace(" ", ",").split(",")
+    return list(dict.fromkeys(x.strip().lower() for x in items if x.strip()))[:200]
+
+
+def state(entry: dict | None, in_library: bool = True) -> dict:
+    e = entry or {}
+    return {"url": e.get("url", ""), "access": e.get("access", "link"), "people": e.get("people", []), "editors": e.get("editors", []), "expires": e.get("expires", ""), "inLibrary": in_library}
+
+
+def publish(deck: Path, op: str = "publish", access=None, people=None, expires=None, editors=None) -> dict:
+    """Share the deck (op "publish": its link, which always shows the latest pushed version) or change who can open it
+    (op "settings": the link stays). Returns state()."""
+    rel, entries = _rel(deck), ledger()
+    e: dict = dict(entries.get(rel) or {"slug": f"{deck.name[:40]}-{secrets.token_urlsafe(8).lower().replace('_', '').replace('-', '')[:10]}"})
+    if access is not None: e["access"] = "people" if access == "people" else "link"
+    if people is not None: e["people"] = _people(people)
+    if editors is not None: e["editors"] = _people(editors)   # who may edit it at glideshow.org/e/…
+    if expires is not None: e["expires"] = expires if len(expires or "") == 10 else ""
+    e.setdefault("access", "link"); e.setdefault("people", []); e.setdefault("editors", [])
+    if op == "publish" or "rev" not in e:   # pin the deck as it is now, its waiting save committed first
+        commit_now(deck)
+        e["rev"] = git(HOME, "rev-parse", "HEAD").stdout.strip()
+    e["title"] = deck_title(deck)
+    e["url"] = f"{config().get('share_site', SITE)}/p/{_owner()}/{e['slug']}/"
+    entries[rel] = e
+    LEDGER.write_text(json.dumps(entries, indent=2) + "\n")
+    commit_library(HOME, f"library: share {deck.name}")   # pushed with it, which is when the link starts to work
+    return state(e)
+
+
+def rekey(old: Path, new: Path) -> None:
+    """A deck (or a folder of decks) moved within the library: its shared entries follow, keeping their links."""
+    try: o, n = (p.resolve().relative_to(HOME.resolve()).as_posix() for p in (old, new))
+    except ValueError: return
+    entries = ledger()
+    moved = {(n + k[len(o):] if k == o or k.startswith(o + "/") else k): v for k, v in entries.items()}
+    if moved != entries: LEDGER.write_text(json.dumps(moved, indent=2) + "\n")
+
+
+def drop(deck: Path) -> None:
+    """A deck (or a folder of decks) removed from the library stops being shared; committed with the removal."""
+    try: rel = deck.resolve().relative_to(HOME.resolve()).as_posix()
+    except ValueError: return
+    entries = ledger()
+    kept = {k: v for k, v in entries.items() if k != rel and not k.startswith(rel + "/")}
+    if kept != entries: LEDGER.write_text(json.dumps(kept, indent=2) + "\n")
+
+
+def status(deck: Path) -> dict:
+    """Share's view of the deck: its link ('' when not shared), who can open it, until when."""
+    try: rel = deck.resolve().relative_to(HOME.resolve()).as_posix()
+    except ValueError: return state(None, in_library=False)
+    return state(ledger().get(rel))
+
+
+def unpublish(deck: Path):
+    rel, entries = _rel(deck), ledger()
+    if rel not in entries: raise SystemExit(f"{rel} is not shared")
+    del entries[rel]
+    LEDGER.write_text(json.dumps(entries, indent=2) + "\n")
+    commit_library(HOME, f"library: stop sharing {deck.name}")