"""
LLM Cinema — the inline STAGE (Gradio app, the hackathon submission).
The "Cinema" model writes, draws, and directs ORIGINAL ASCII films that play
INLINE on a little charcoal terminal-stage — no separate window, no sound, just
the model's imagination streaming frame by frame.
• a showpiece film auto-plays the moment the page loads (no model call needed)
• Make a film from any concept • a Gallery of films that replay instantly
• download your film as a GIF to share
Run: python stage.py
Deploy: Hugging Face Space (Gradio). Set CLAUDEMOVIES_LLM_URL/_KEY/_MODEL secrets.
"""
import glob
import html
import json
import os
import random
import re
import threading
import time
import uuid
import gradio as gr
import movies
import render
def warm_endpoints():
"""Wake the scale-to-zero model endpoints in the background, so the first
real 'Make a film' doesn't eat the whole cold start. Safe to call often."""
def ping(prefix):
try:
movies.llm("Warmup.", "ok", max_tokens=1, prefix=prefix)
except Exception:
pass
for prefix in ("CLAUDEMOVIES_LLM", "CLAUDEMOVIES_ADV"):
threading.Thread(target=ping, args=(prefix,), daemon=True).start()
W, H = render.W, render.H
HERE = os.path.dirname(__file__)
SHOW = os.path.join(HERE, "showcase")
SAVED = os.path.join(HERE, "saved")
SURPRISES = [
"a tiny knight who is afraid of the dark", "a lonely robot who finds a stray cat",
"a dragon who would rather bake than fight", "two fireflies falling in love over a pond",
"a grumpy troll who secretly wants to dance", "a snail who dreams of racing the wind",
"a little ghost afraid of humans", "a paper boat's voyage to the endless sea",
"a mouse who builds a ladder to the moon", "a candle racing the dawn",
]
# ── render a frame-grid to coloured HTML for the inline stage ──────────────────
def grid_to_html(grid, title=""):
rows = []
for r in range(H):
cells, row, i = grid[r], "", 0
while i < W:
col, j, seg = cells[i][1], i, ""
while j < W and cells[j][1] == col:
seg += cells[j][0]
j += 1
hexc = "#%02x%02x%02x" % col if isinstance(col, tuple) else "#7CFC9A"
esc = html.escape(seg)
row += f"{esc}" if seg.strip() else esc
i = j
rows.append(row)
return (f""
f"{html.escape(title)}
{chr(10).join(rows)}LLM Cinema
"
f"
{html.escape(msg)}"
"ready · awaiting your idea
"
f"
{body}LLM CINEMA
"
"a tiny fine-tuned model writes, draws & "
"directs original ASCII films
")
gr.HTML("Your film
")
concept = gr.Textbox(show_label=False, lines=3, max_lines=3, elem_id="concept",
placeholder="Describe your film — e.g. a tiny knight afraid of the dark")
go = gr.Button("▸ Make & play", variant="primary", elem_id="makebtn")
with gr.Row(elem_id="makerow"):
surprise = gr.Button("Surprise", size="sm")
stop = gr.Button("Stop", size="sm", elem_id="stopbtn")
gr.HTML("Now playing
")
now_playing = gr.HTML("—
")
gr.HTML("Rate & save
")
with gr.Row(elem_id="rating"):
star_btns = [gr.Button("★", elem_classes="star") for _ in range(5)]
rate_msg = gr.HTML("", elem_id="ratemsg")
dl = gr.Button("Download GIF", size="sm")
dlfile = gr.File(label="your film", visible=False)
gr.HTML("Gallery
")
film_btns = [(t, gr.Button(t, elem_classes="film", size="sm")) for t in gallery]
# ── RIGHT: the cinema ──
with gr.Column(elem_id="cinema"):
stage = gr.HTML(_welcome())
# on load: assign a per-session id + force dark/star-hover (client js), then quietly
# warm the model endpoints. No auto-played preview — the viewer is invited to make one.
load_ev = demo.load(_newsid, None, sid, js=FORCE_DARK)
load_ev.then(lambda: warm_endpoints(), None, None)
def _create(concept, sid):
"""Write a film, streaming progress to the stage and surfacing any error.
Yields (stage_html, spec) tuples; on success ends by playing the film."""
mine = _begin(sid) # take the screen — supersedes the opening film
concept = (concept or "").strip()
if not concept:
yield _idle("Type a concept first, then press Make & play."), None
return
if _blocked(concept):
yield _idle("Let's keep it friendly — that idea can't be filmed.\n\n"
"Try something kind, funny or imaginative."), None
return
# Run the model call in a thread and emit a heartbeat ~once a second while
# it works. This both shows live progress AND keeps the stream alive — a
# silent 60-90s cold-start block would make Gradio drop and restart the
# generator, which is what made it loop the intro forever.
result = {}
def work():
try:
result["spec"] = movies.direct(concept)
except Exception as e: # network / endpoint failure
result["error"] = f"{type(e).__name__}: {e}"
th = threading.Thread(target=work, daemon=True)
th.start()
t0, dots = time.time(), 0
while th.is_alive():
if GEN.get(sid) != mine: # the viewer started something else
return
dots = dots % 3 + 1
yield _idle(f"Concept:\n {concept}\n\nCinema is writing your film"
+ "." * dots + "\n\n"
+ f"({int(time.time() - t0)}s — the model may be waking up; "
"the first request can take a minute)"), None
th.join(timeout=0.7)
if GEN.get(sid) != mine:
return
if result.get("error"):
yield _idle("Could not reach the Cinema model.\n\n"
f"{result['error']}\n\nPlease try again in a moment."), None
return
spec = result.get("spec")
if not spec or not spec.get("shots"):
yield _idle("The model returned nothing usable. Please try again."), None
return
# NOTE: we intentionally do NOT persist user films — each creation is private to
# the maker's own session (per-session playback token) and never shown to others.
yield _idle(f"\"{spec.get('title', concept)}\"\n\n"
f"{len(spec['shots'])} shots written. Drawing and rolling…"), None
yield from _stream(spec, sid, mine)
def make_and_play(c, sid):
yield from _create(c, sid)
def surprise_me(sid):
yield from _create(random.choice(SURPRISES), sid)
def stop_play(sid):
_begin(sid) # supersede any running film/generation
# re-assert the welcome a few times so a trailing/buffered film frame from the
# stream we just cancelled can't land on top of it
for _ in range(5):
yield _welcome(), None
time.sleep(0.25)
go.click(make_and_play, [concept, sid], [stage, last_spec])
surprise.click(surprise_me, sid, [stage, last_spec])
stop.click(stop_play, sid, [stage, last_spec])
def rate(n):
def f(spec):
try:
with open(os.path.join(HERE, "ratings.jsonl"), "a") as fp:
fp.write(json.dumps({"stars": n,
"title": (spec or {}).get("title", "")}) + "\n")
except Exception:
pass
stars = "★" * n + "☆" * (5 - n)
return (f"{stars}"
f" Thanks!")
return f
for i, b in enumerate(star_btns, 1):
b.click(rate(i), last_spec, rate_msg)
def to_gif(spec):
if not spec:
return gr.update(visible=False)
gif, _, _ = render.render_spec(spec)
return gr.update(value=gif, visible=True)
dl.click(to_gif, last_spec, dlfile)
def make_play(title):
def f(sid):
path = gallery.get(title)
if not path:
return
yield from _stream(json.load(open(path)), sid, _begin(sid))
return f
for title, btn in film_btns:
btn.click(make_play(title), sid, [stage, last_spec])
# keep the shelf "Now playing" in sync with whatever film is on screen (wraps, no truncation)
def _np(spec):
title = (spec or {}).get("title") or "—"
return f"{html.escape(title)}
"
last_spec.change(_np, last_spec, now_playing)
# explicit queue: streaming relies on it, and a higher concurrency lets several
# viewers (judges) watch at once instead of waiting in line
demo.queue(default_concurrency_limit=12)
return demo
demo = build()
warm_endpoints() # start waking the model the moment the Space boots
if __name__ == "__main__":
demo.launch(theme=THEME, css=CSS)