Spaces:
Runtime error
Runtime error
| """From a written deck to what is stored and shown. `finish` picks each slide's variant, fits its text, and checks | |
| the result in Chrome when one is installed. `restructure` takes a deck back from the editor and fits it again. | |
| `view` reads a stored deck back (clamped again, so older or edited decks still draw) and gives its pages; one slide | |
| that cannot be drawn becomes a plain one instead of breaking the deck.""" | |
| import copy | |
| import logging | |
| import random | |
| from collections import Counter | |
| from app.infographics.image import ImageUnavailable | |
| from app.slides import export | |
| from app.slides.content import clamp_deck, clamp_slide, empty_slide | |
| from app.slides.layout import GEOMETRY, SCALES, VARIANTS, assign_variants, compose, fits_variant, seed_of | |
| from app.slides.render import slide_html | |
| from app.slides.themes import theme_id | |
| log = logging.getLogger(__name__) | |
| def fit(deck: dict, theme: str, fmt: str, seed: int) -> dict: | |
| """Every slide as it will be drawn: text shortened where it had to be, so what is stored is what is shown.""" | |
| out = copy.deepcopy(deck) | |
| out["slides"] = [compose(out, i, theme, fmt, seed).slide for i in range(len(out["slides"]))] | |
| return out | |
| def finish(deck: dict, theme: str, fmt: str, seed: int, previous: list[tuple[str, str]] | None = None) -> dict: | |
| """Variants, then refit. Raises ValueError when a slide cannot be drawn at all.""" | |
| theme = theme_id(theme) | |
| deck = copy.deepcopy(deck) | |
| assign_variants(deck["slides"], theme, seed, previous) | |
| return refit(deck, theme, fmt, seed) | |
| def refit(deck: dict, theme: str, fmt: str, seed: int) -> dict: | |
| """Fitted text and a Chrome check that no text box overflows (slides that do are drawn a step smaller and fitted | |
| again), keeping each slide's variant. Raises ValueError when a slide cannot be drawn at all.""" | |
| theme = theme_id(theme) | |
| deck = fit(deck, theme, fmt, seed) | |
| for _ in range(3): | |
| try: | |
| bad = export.overflowing(deck, theme, fmt, seed) | |
| except ImageUnavailable: | |
| break # no Chrome here: the measured fit alone keeps text inside its boxes | |
| if not bad: | |
| break | |
| log.info("slides %s overflow in Chrome, drawing them smaller", sorted(bad)) | |
| for i in bad: | |
| deck["slides"][i]["shrink"] = min(int(deck["slides"][i].get("shrink") or 0) + 1, len(SCALES) - 1) | |
| deck = fit(deck, theme, fmt, seed) | |
| for i in range(len(deck["slides"])): | |
| slide_html(deck, i, theme, fmt, seed) # raises if a slide cannot be drawn: better now than when shown | |
| return deck | |
| class BadEdit(ValueError): | |
| """A deck sent back from the editor that cannot be kept (no slides, or too many).""" | |
| MAX_SLIDES = 30 | |
| def fill_variants(slides: list[dict], theme: str, seed: int) -> None: | |
| """Give a variant, in place, to each slide that has none or whose variant no longer suits it (a new slide, a changed | |
| layout, a card row now with five points). Every other slide keeps its own, so editing one slide never redraws the | |
| rest. The choice follows assign_variants: suited to the content, not the same as a neighbour, unused ones first.""" | |
| theme = theme_id(theme) | |
| def ok(i: int) -> bool: | |
| s = slides[i] | |
| return s["variant"] in VARIANTS[s["layout"]] and fits_variant(s, theme, s["variant"]) | |
| keep = [ok(i) for i in range(len(slides))] | |
| for i, s in enumerate(slides): | |
| before = (slides[i - 1]["layout"], slides[i - 1]["variant"]) if i else None | |
| if keep[i] and (s["layout"], s["variant"]) != before: | |
| continue | |
| after = (slides[i + 1]["layout"], slides[i + 1]["variant"]) if i + 1 < len(slides) and keep[i + 1] else None | |
| options = [v for v in VARIANTS[s["layout"]] if fits_variant(s, theme, v)] or list(VARIANTS[s["layout"]]) | |
| fresh = [v for v in options if (s["layout"], v) not in (before, after)] or options | |
| used = Counter((x["layout"], x["variant"]) for j, x in enumerate(slides) if j != i) | |
| rnd = random.Random(seed + i) | |
| s["variant"] = min(fresh, key=lambda v: (used[(s["layout"], v)], rnd.random())) | |
| keep[i] = True | |
| def restructure(content: dict, slides: object, final: bool) -> dict: | |
| """The stored deck with the slides the editor sent (text edited, slides added, removed, moved, or changed to another | |
| layout). They are coerced like model output (clamp_deck: plain text, the format's limits, valid layouts), slides | |
| that need one get a variant, and the deck is fitted: quickly for a preview, with the Chrome check when `final`.""" | |
| got = stored(content) | |
| if not got: | |
| raise BadEdit("This deck has no slides to edit.") | |
| deck, theme, fmt, seed = got | |
| if not isinstance(slides, list) or not slides: | |
| raise BadEdit("A deck needs at least one slide.") | |
| if len(slides) > MAX_SLIDES: | |
| raise BadEdit(f"A deck can have at most {MAX_SLIDES} slides.") | |
| new = clamp_deck({"title": deck["title"], "subtitle": deck["subtitle"], "slides": slides}, fmt) | |
| if not new: | |
| raise BadEdit("A deck needs at least one slide with a heading.") | |
| for s in new["slides"]: | |
| s["shrink"] = 0 # text changed: fitted afresh, so shorter text can be drawn larger again | |
| fill_variants(new["slides"], theme, seed) | |
| return refit(new, theme, fmt, seed) if final else fit(new, theme, fmt, seed) | |
| def slots(content: dict) -> list[list[str]]: | |
| """For each slide, the parts its variant has a place for (kicker, lead, body, by, closing...): what the editor | |
| can offer to add.""" | |
| got = stored(content) | |
| if not got: | |
| return [] | |
| deck, theme, _fmt, _seed = got | |
| out = [] | |
| for s in deck["slides"]: | |
| variants = GEOMETRY[theme][s["layout"]] | |
| out.append(sorted(k for k, v in (variants.get(s["variant"]) or next(iter(variants.values()))).items() if v)) | |
| return out | |
| def stored(content: dict) -> tuple[dict, str, str, int] | None: | |
| """A stored deck, clamped, with its theme, format and seed (None when there is none).""" | |
| fmt = content.get("format") if content.get("format") in ("detailed", "presenter") else "detailed" | |
| deck = clamp_deck(content.get("deck") or {}, fmt) | |
| if not deck: | |
| return None | |
| return deck, theme_id(content.get("theme")), fmt, seed_of(content.get("seed")) | |
| def _placeholder(deck: dict, index: int) -> dict: | |
| s = empty_slide("section") | |
| s["heading"] = deck.get("title") or "Slide" | |
| return clamp_slide(s, "detailed") | |
| def view(content: dict) -> list[str]: | |
| """Each slide of a stored deck as a standalone page.""" | |
| got = stored(content) | |
| if not got: | |
| return [] | |
| deck, theme, fmt, seed = got | |
| pages = [] | |
| for i in range(len(deck["slides"])): | |
| try: | |
| pages.append(slide_html(deck, i, theme, fmt, seed)) | |
| except Exception: | |
| log.exception("slide %s could not be drawn", i) | |
| safe = copy.deepcopy(deck) | |
| safe["slides"][i] = _placeholder(deck, i) | |
| pages.append(slide_html(safe, i, theme, fmt, seed)) | |
| return pages | |