"""
def _chamber_eyebrow(left: str, right: str = "") -> str:
r = f'·{right}' if right else ""
return f'
{left}{r}
'
def _chamber_title(text: str) -> str:
return f'
{text}
'
def _chamber_body(html: str) -> str:
return f'
{html}
'
def _chamber_callout(tag: str, html: str) -> str:
extra_class = " tonight-card" if tag == "tonight's move" else ""
return f'
{tag}{html}
'
def _chamber_meta(pairs: list[tuple[str, str]]) -> str:
items = "".join(f'{k}{v}' for k, v in pairs)
return items
def _constellation_rail(state: AppState) -> str:
"""Horizontal rail of voice orbs — matches the Expo app's voiceGrid language."""
stars = _constellation(state)
items = []
for cm, label, st, hint in stars:
initials = "".join(w[0] for w in label.split()[:2]).upper() or "??"
state_label = {"lit": "live", "dim": "faint", "locked": "off-air"}[st]
tooltip = f' title="{_unlock_criteria(cm)}"' if st == "locked" else ""
items.append(
f'
'
f'{state_label}'
f'
{initials}
'
f'
{label}
'
f'
'
)
return f"""
✦ constellation · {sum(1 for _, _, s, _ in stars if s == "lit")} of {len(stars)} live
"""
_STEPS = [
("onboard", "Onboard"),
("check-in", "Check-in"),
("generate", "Generate"),
("choose", "Choose"),
]
def _signal_path(current: str) -> str:
"""Horizontal signal-path progress, not step pills."""
if current not in {k for k, _ in _STEPS}:
current = "onboard"
idx = next(i for i, (k, _) in enumerate(_STEPS) if k == current)
nodes = []
for i, (k, label) in enumerate(_STEPS):
cls = "done" if i < idx else ("now" if i == idx else "")
nodes.append(f'
status · building your messagechannel · your future self is listening
"""
def _audio_module(label: str, audio_path: str) -> str:
"""Audio player styled as an instrument readout, not a card.
audio_path is a Gradio-served path (either a Kokoro tempfile or a
staged static file in the temp dir). The /file= prefix is Gradio's
file-serving endpoint; the bare path doesn't work for arbitrary
repo files on HF Spaces.
"""
if not audio_path:
return ""
if audio_path.startswith("/file="):
src = audio_path
else:
src = f"/file={audio_path}"
return f"""
voice transmission· from {label}
"""
def _audio_dropped_module(label: str) -> str:
"""Visible callout when both Kokoro and the pre-rendered fallback audio failed.
Without this, the chamber silently renders text-only and the user assumes
the demo is broken. Make the failure mode part of the product voice.
"""
label_safe = html_escape(label)
return f"""
voice line dropped· {label_safe} could not be tuned
The text arrived but the voice did not. The transmission is still legible above.
"""
def _share_module(title: str, body: str, action: str, cliff: str) -> str:
"""A copy-to-clipboard button for the transmission, styled as an instrument.
Judges (and demo viewers) often want to share the transmission
text without having to retype it. The button copies the full
transmission (title, body, action, cliffhanger) to the clipboard
via a tiny vanilla-JS handler. The visible label is a short
label; the copied text is the full transmission.
"""
safe = (
body.replace("\\", "\\\\").replace("`", "\\`").replace("$", "\\$")
if body else ""
)
payload = (
f"{title}\\n\\n{body}\\n\\n— Tonight: {action}\\n— Tomorrow: {cliff}\\n\\n— from FutureSelves"
).replace("\\", "\\\\").replace("`", "\\`").replace("$", "\\$").replace("\n", "\\n")
return f"""
share with someone you trust
"""
def _memory_log(state: AppState, *, limit: int = 8) -> str:
"""Memory log — grid of timestamped rows, not stacked cards.
When the state carries demo-audio mapping (e.g. Maya's loaded state),
past transmissions render a tiny play chip that links to the
pre-rendered audio. The mapping is a hard-coded lookup keyed on
transmission title so it works for the demo without polluting
AppState's schema.
"""
demo_audio = _demo_audio_lookup()
if not state.recent_choices and not state.recent_transmissions:
return ""
rows = []
for t in reversed(state.recent_transmissions[-limit:]):
audio_chip = ""
if t.title in demo_audio:
rel = demo_audio[t.title]
staged = _stage_static_audio(rel)
if staged:
audio_chip = (
f'▶'
)
cast_label = CAST_MEMBER_NAMES.get(t.cast_member, ("", ""))[0] or t.cast_member
rows.append(
f'
'
f'{html_escape(t.date_key)}'
f'“{html_escape(t.title)}”'
f'{html_escape(cast_label)}{audio_chip}'
f'
'
)
for c in reversed(state.recent_choices[-limit:]):
# c.choice is enum-like (toward/steady/release/repair) but escape for safety.
choice_safe = html_escape(c.choice)
rows.append(
f'
'
f'{html_escape(c.date_key)}'
f'{html_escape(c.prompt)}'
f'{choice_safe}'
f'
'
)
return f"""
memory log · last {min(limit, len(rows))} signals
{''.join(rows)}
"""
def _demo_audio_lookup() -> dict[str, str]:
"""Map demo transmission titles to their pre-rendered audio file paths.
These are the Maya demo transmissions — pre-written for the "Try
Maya's example" button. When a judge's state has these titles in its
memory log, we render a play chip beside the title.
Audio files are committed to the repo at audio/voices/. They're
served via _stage_static_audio (Gradio temp dir) at the time the
chip is rendered, not via the repo root.
"""
return {
"You know which conversation you keep rescheduling": "audio/voices/day-04-shadow.wav",
"You are not behind. You are building.": "audio/voices/day-03-mentor.wav",
"You are softer than the world taught you to be": "audio/voices/day-02-partner.wav",
"The weight you are carrying is not all yours to carry": "audio/voices/day-01-self.wav",
"The threshold is a door, not a wall": "audio/voices/today-threshold.wav",
}
def _render_persona_card() -> str:
"""Render the demo persona summary in the architecture tab.
Reads from traces/persona-summaries.json. If the file is empty or
missing, returns a placeholder. The summary is a 1-paragraph
narrative description of who Maya is, generated by the Modal
function (or the local heuristic fallback). Showing it in the
architecture tab is how judges verify the Modal integration.
"""
summary_file = Path(__file__).parent / "traces" / "persona-summaries.json"
if not summary_file.exists():
return 'no persona summary yet — generate one via the demo button'
try:
summaries = json.loads(summary_file.read_text())
except json.JSONDecodeError:
return 'persona summary file corrupted'
if not summaries:
return 'no persona summary yet — generate one via the demo button'
last = summaries[-1]
src = html_escape(last.get("source", "?"))
summary = html_escape(last.get("summary", ""))
name = html_escape(last.get("persona_name", "?"))
return (
f''
f'“{summary}”'
f'
'
f'— {name} · via {src}
'
)
def _signal_footer() -> str:
return """"""
def _context_note(html: str) -> str:
"""Single small fallback surface for messages that don't fit the chamber. Used sparingly."""
return f'
{html}
'
# ─── App logic (async gen helper) ─────────────────────────────────────────────
def _gen_async(state: AppState, context: GenerationContext, cm: CastMember, now_str: str):
import time as _time
start = _time.time()
result, source = _generate_with_llm(context, cm, now_str)
state.today_transmission = result
# Try local Kokoro first. If it fails (Space, missing deps, etc.) and we
# have a matching pre-rendered voice sample for the cast member, fall
# back to that — the demo stays alive even when TTS is unavailable.
audio = generate_speech(result.text, voice=get_voice_for_cast_member(cm))
if not audio:
audio = _fallback_demo_audio(cm)
state.today_audio = audio or ""
state.generating = False
state.generation_done = True
# Log the full agent trace (system prompt + user prompt + raw output +
# parsed JSON) for the Sharing is Caring bonus quest. This runs on
# every live generation, so judges can audit the agent's decisions.
duration_ms = int((_time.time() - start) * 1000)
try:
from transmission import build_prompt, get_system_prompt
sys_p = get_system_prompt(context.persona.timeline_divergence_score)
usr_p = build_prompt(context, cm)
parsed = {
"title": result.title, "text": result.text,
"actionPrompt": result.action_prompt, "cliffhanger": result.cliffhanger,
} if result else None
# Run note extraction (Nemotron-Parse or keyword fallback) for the trace
insights = None
if context.check_in and context.check_in.note:
try:
ins = extract_note_insights(context.check_in.note) or fast_insights(context.check_in.note)
if ins:
insights = {
"sentiment": ins.sentiment, "emotions": ins.emotions,
"themes": ins.themes, "intensity": ins.intensity,
}
except Exception:
pass
log_agent_trace(
persona_name=context.persona.name,
cast_member=cm,
system_prompt=sys_p,
user_prompt=usr_p,
raw_output=result.text if result else "",
parsed_output=parsed,
insights=insights,
duration_ms=duration_ms,
source=source,
)
except Exception as exc:
logger.warning("Failed to log agent trace: %s", exc)
def _fallback_demo_audio(cm: CastMember) -> Optional[str]:
"""Map cast members to their pre-rendered voice samples.
Used when Kokoro is unavailable (HF Space, missing dep chain) so
the transmission still arrives with a voice. Each cast member has
at most one canned voice sample that loops the canonical phrase
for that voice; in a real product this would be replaced by
Kokoro output, but for the demo it gives judges a real voice to
hear even when MiniCPM and Kokoro aren't running.
The file is copied to a Gradio temp dir so it's served via the
/file= endpoint (Gradio does NOT serve arbitrary files from the
repo root on a Space — it only serves from its temp dir).
"""
sample_map = {
"future_self": "audio/voices/today-threshold.wav",
"future_partner": "audio/voices/day-02-partner.wav",
"future_mentor": "audio/voices/day-03-mentor.wav",
"shadow": "audio/voices/day-04-shadow.wav",
}
rel = sample_map.get(cm)
if not rel:
return None
return _stage_static_audio(rel)
def _stage_static_audio(rel_path: str) -> Optional[str]:
"""Copy a static audio file to Gradio's temp dir so it's served at /file=.
Gradio Spaces serve user files at /file= only for
files in the temp dir. Files in the repo root (audio/voices/...)
are NOT served at the root URL. We copy the file once and cache
the destination path, so the cost is one shutil.copy per file
per session, not per request.
"""
if not hasattr(_stage_static_audio, "_cache"):
_stage_static_audio._cache = {}
if rel_path in _stage_static_audio._cache:
cached = _stage_static_audio._cache[rel_path]
if os.path.exists(cached):
return cached
src = Path(__file__).parent / rel_path
if not src.exists():
logger.warning("Static audio not found: %s", src)
return None
# Use a stable filename in the temp dir so caching works
dest_dir = Path(tempfile.gettempdir()) / "futureselves_audio"
dest_dir.mkdir(parents=True, exist_ok=True)
dest = dest_dir / src.name
if not dest.exists():
shutil.copy(str(src), str(dest))
_stage_static_audio._cache[rel_path] = str(dest)
return str(dest)
# ─── Renderers — each returns the same shell, swaps only the chamber content ─
def _state_for_path(state: AppState) -> str:
"""Map app state to a signal-path key."""
if state.generating and not state.generation_done:
return "generate"
if state.today_transmission and not state.choice_made:
return "choose" if state.checked_in else "generate"
if state.checked_in and not state.today_transmission:
return "generate"
if state.checked_in:
return "generate"
return "check-in"
def _render_home(state: AppState, ack: str = "") -> str:
p = state.persona or _default_persona()
name_safe = html_escape(p.name or "you")
city_safe = html_escape(p.city or "everywhere")
chapter_safe = html_escape(p.current_chapter or "a chapter still forming")
avoiding_safe = html_escape(p.avoiding or "something you keep circling")
eyebrow = _chamber_eyebrow("line idle", f"{name_safe} · {city_safe}")
title = _chamber_title(f"Ready when you are, {name_safe}.")
continuity_hint = ""
if state.recent_choices:
last_choice = state.recent_choices[-1]
choice_labels = {
"toward": "moved toward what matters",
"steady": "held your ground",
"release": "let something go",
"repair": "mended a frayed thread",
}
continuity_hint = f" The line has been listening since you last chose to {choice_labels.get(last_choice.choice, 'continue')}."
if not state.onboarded:
body_html = _chamber_body(
"Give the line one word. I'll turn it into something "
"your future self needs you to hear tonight."
)
else:
body_html = _chamber_body(
f"Check in with one word to open the line. "
f"You are in {chapter_safe}, "
f"and avoiding {avoiding_safe}."
f"{continuity_hint}"
)
callout = ""
if ack == "memory":
callout = _chamber_callout(
"remembered",
"I’ll remember that for tomorrow. The line is ready when you are."
)
elif not state.onboarded and state.recent_transmissions:
callout = _chamber_callout(
"make it yours",
f'Want tomorrow’s signal to know you better? '
f'Personalize your line →'
)
elif state.recent_transmissions:
last = state.recent_transmissions[-1]
callout = _chamber_callout(
"last transmission",
f'“{html_escape(last.title)}” · {html_escape(last.date_key)}'
)
chapter_truncated = p.current_chapter[:40] + "…" if p.current_chapter and len(p.current_chapter) > 40 else (p.current_chapter or "—")
meta = _chamber_meta([
("arc", html_escape(p.primary_arc or "—")),
("chapter", html_escape(chapter_truncated)),
])
out = _identity_strip(state)
out += _signal_chamber(eyebrow, title, body_html, meta_html=meta, callout_html=callout)
out += _constellation_rail(state)
out += _signal_path(_state_for_path(state))
out += _memory_log(state)
out += _signal_footer()
return out
def _render_generating(cast: CastMember, word: str = "") -> str:
label = CAST_MEMBER_NAMES.get(cast, ("", ""))[0] or cast
word_safe = html_escape(word.strip()) if word.strip() else ""
eyebrow = _chamber_eyebrow("tuning the line", label)
title = _chamber_title(f'{label} is reaching across time.')
if word_safe:
body_html = _chamber_body(f'I’m turning “{word_safe}” into something you can use tonight.')
else:
body_html = _chamber_body("Stand by. The signal is being assembled from your last few days.")
body_html += _tuning_display(label)
meta = _chamber_meta([
("channel", "α-04"),
("depth", "340ms"),
("cast", label),
])
out = _identity_strip(AppState()) # state not threaded here; identity is enough
out += _signal_chamber(eyebrow, title, body_html, meta_html=meta)
out += _signal_path("generate")
out += _signal_footer()
return out
def _render_transmission(state: AppState) -> str:
t = state.today_transmission
if not t:
return _render_home(state)
label = CAST_MEMBER_NAMES.get(state.today_cast or "future_self", ("", ""))[0] or "Future Self"
title_safe = html_escape(t.title or "")
text_safe = html_escape(t.text or "")
action_safe = html_escape(t.action_prompt or "")
cliff_safe = html_escape(t.cliffhanger or "")
eyebrow = _chamber_eyebrow("transmission received", label)
title = _chamber_title(f'{title_safe}')
body_html = _chamber_body(text_safe)
actions = ""
if state.today_audio:
actions = _audio_module(label, state.today_audio)
elif state.generation_done:
actions = _audio_dropped_module(label)
# Share module gets raw text — it's payload-encoded for clipboard, not HTML-interpolated.
actions += _share_module(t.title, t.text, t.action_prompt, t.cliffhanger)
# The chamber holds the audio module + tonight's move. Tomorrow's cliffhanger
# is shown as a second anchor line below the chamber so the page has a clear
# rhythm: text → audio + tonight → tomorrow → constellation → memory log.
tonight = _chamber_callout("tonight's move", action_safe)
tomorrow = _chamber_callout("tomorrow", cliff_safe)
out = _identity_strip(state)
out += _signal_chamber(eyebrow, title, body_html, actions_html=actions, callout_html=tonight)
out += tomorrow
out += _constellation_rail(state)
out += _signal_path("choose")
out += _memory_log(state, limit=5)
out += _signal_footer()
return out
def _unlock_criteria(cm: str) -> str:
"""Return unlock criteria tooltip for locked voice orbs."""
criteria = {
"future_partner": "Unlock: Choose love arc · divergence < 4",
"future_mentor": "Unlock: 7-day streak · choose steady/toward 7×",
"future_best_friend": "Unlock: 3-day streak · choose repair once",
"shadow": "Unlock: divergence ≥ 4 · timeline fracture",
"alternate_self": "Unlock: 14-day streak · timeline drift",
}
return criteria.get(cm, "locked")
def _render_history(state: AppState) -> str:
out = _identity_strip(state)
eyebrow = _chamber_eyebrow("memory log", "transmissions and choices")
title = _chamber_title("Every signal so far.")
if not state.recent_choices and not state.recent_transmissions:
body = _chamber_body(
"The line is idle. One word on the Today tab starts the transmission."
)
out += _signal_chamber(eyebrow, title, body, actions_html='
')
else:
body = _chamber_body("Scroll for the full record of what was said and what you chose.")
out += _signal_chamber(eyebrow, title, body)
out += _constellation_rail(state)
out += _memory_log(state, limit=20)
out += _signal_path("choose" if state.choice_made else "check-in")
out += _signal_footer()
return out
# ─── Build Gradio UI ─────────────────────────────────────────────────────────
def create_app():
# Bootstrap: write the Modal app source and the demo trace on first
# boot. These are committed to the repo but regenerating them at
# startup means judges always see a current trace + a current
# Modal function definition.
try:
write_modal_app()
write_demo_trace()
except Exception as exc:
logger.warning("Startup bootstrap failed: %s", exc)
# Off Brand: typewriter effect on transmission text
js_code = """
function startTypewriter() {
const el = document.querySelector('.typewriter');
if (!el || el.dataset.typed) return;
el.dataset.typed = '1';
const text = el.textContent;
el.textContent = '';
el.style.visibility = 'visible';
let i = 0;
function type() {
if (i < text.length) {
el.textContent += text.charAt(i);
i++;
setTimeout(type, 6 + Math.random() * 12);
}
}
type();
}
setInterval(startTypewriter, 500);
startTypewriter();
// ─── Example chip handler — click to populate textbox ───
function setupExampleChips() {
document.querySelectorAll('.ex-chip').forEach(chip => {
if (chip.dataset.wired) return;
chip.dataset.wired = '1';
chip.addEventListener('click', function(e) {
e.preventDefault();
const fieldId = this.dataset.field;
const value = this.dataset.value;
// Find the textarea/input inside the field container
const container = document.getElementById(fieldId);
if (!container) return;
const input = container.querySelector('textarea, input');
if (!input) return;
// Set value natively so Gradio picks it up
const nativeSetter = Object.getOwnPropertyDescriptor(
input.tagName === 'TEXTAREA' ? window.HTMLTextAreaElement.prototype : window.HTMLInputElement.prototype,
'value'
).set;
nativeSetter.call(input, value);
input.dispatchEvent(new Event('input', { bubbles: true }));
input.dispatchEvent(new Event('change', { bubbles: true }));
// Visual feedback
const orig = this.textContent;
this.textContent = '\u2713';
this.classList.add('used');
setTimeout(() => { this.textContent = orig; this.classList.remove('used'); }, 1200);
});
});
}
// ─── Choice/reaction card handler — click to select ───
function setupCardSelection() {
document.querySelectorAll('.choice-card, .reaction-card, .arc-card, .memory-card').forEach(card => {
if (card.dataset.wired) return;
card.dataset.wired = '1';
card.addEventListener('click', function(e) {
e.preventDefault();
const grid = this.closest('.card-grid');
if (!grid) return;
// Deselect all cards in this grid
grid.querySelectorAll('.choice-card, .reaction-card, .arc-card, .memory-card').forEach(c => c.classList.remove('active'));
// Select this card
this.classList.add('active');
// Find the hidden radio widget by elem_id and click the matching option
let gridClass = 'field-memory';
if (grid.classList.contains('choice-grid')) gridClass = 'field-choice';
else if (grid.classList.contains('reaction-grid')) gridClass = 'field-reaction';
else if (grid.classList.contains('memory-grid')) gridClass = 'field-memory';
else if (grid.classList.contains('arc-grid')) gridClass = 'field-oarc';
const radioWidget = document.getElementById(gridClass);
if (!radioWidget) return;
const val = this.dataset.value;
// Find the radio input with matching value attribute
const radio = radioWidget.querySelector('input[value="' + val + '"]');
if (radio) {
radio.click();
} else {
// Fallback: try clicking the label
const labels = radioWidget.querySelectorAll('.gr-radio-label');
labels.forEach(label => {
if (label.textContent.trim().toLowerCase() === val) {
label.click();
}
});
}
});
});
}
// Re-run after Gradio re-renders
function setupInteractions() {
setupExampleChips();
setupCardSelection();
}
setInterval(setupInteractions, 800);
setupInteractions();
"""
with gr.Blocks(
css=CSS,
# No Inter. Fraunces for the chamber voice, IBM Plex Mono for instrument labels.
# Pass an empty font list to gr.themes.Base so the @import in CSS wins.
# Color() takes 11 shades (c50..c950) — built around our chamber palette.
theme=gr.themes.Base(
primary_hue=gr.themes.Color(
c50="#fbf3e3", c100="#f5e3bd", c200="#eed29a", c300="#e7c277",
c400="#e0b15a", c500="#e9a847", c600="#c4842d", c700="#a06820",
c800="#7a4a14", c900="#5a3608", c950="#3a2205",
),
secondary_hue=gr.themes.Color(
c50="#ece9f8", c100="#d6cef0", c200="#bcb0e7", c300="#a192de",
c400="#8b7cd3", c500="#7a6cc7", c600="#5b4ea6", c700="#3f3470",
c800="#2c234d", c900="#1a1530", c950="#0d0a1c",
),
neutral_hue=gr.themes.Color(
c50="#f6efdc", c100="#d8d0bd", c200="#b8b09c", c300="#9c9485",
c400="#7e766a", c500="#5a5f75", c600="#3a3f55", c700="#2a2e42",
c800="#1c2032", c900="#141a30", c950="#0a0c1a",
),
font=["IBM Plex Mono", "ui-monospace", "monospace"],
font_mono=["IBM Plex Mono", "ui-monospace", "monospace"],
),
title="FutureSelves",
head=(
# Google Fonts via , not CSS @import — async, not blocked by
# CSP, works in HF Space iframes. Two faces only: Fraunces for the
# chamber voice, IBM Plex Mono for instrument labels and signal path.
""
""
""
f""
),
) as demo:
browser_state = gr.BrowserState(None)
state = gr.State(init_state())
demo.load(fn=lambda d: AppState.from_dict(d), inputs=[browser_state], outputs=[state])
with gr.Tabs(elem_classes="tab-nav"):
# ── Today tab ──────────────────────────────────────────────
with gr.Tab("Today"):
# Initial chamber content shown before the page hydrates. Mirrors
# _render_home() for the unonboarded state so there's no flash.
content = gr.HTML(
_signal_chamber(
_chamber_eyebrow("line idle", "you · everywhere"),
_chamber_title("Ready when you are, you."),
_chamber_body("Give the line one word. I'll turn it into something your future self needs you to hear tonight."),
)
)
with gr.Column(visible=False) as onboard_col:
# Primer line — sets emotional tone before the form
gr.HTML(PRIMER_HTML)
with gr.Column(visible=True) as step1_col:
step1_heading = gr.HTML("### 👤 Make it yours")
oname = gr.Textbox(
label="Your name",
placeholder=PLACEHOLDERS["name"],
elem_id="field-oname",
)
octiy = gr.Textbox(
label="Your city",
placeholder=PLACEHOLDERS["city"],
elem_id="field-octiy",
)
step1_btn = gr.Button(BUTTON_TEXT["step1_next"], variant="primary")
with gr.Column(visible=False) as step2_col:
step2_heading = gr.HTML("### 🧭 Your chapter")
ochapter = gr.Textbox(
label="Current life chapter",
lines=2,
placeholder=PLACEHOLDERS["chapter"],
elem_id="field-ochapter",
)
# Arc selection rendered as 4 cards, not a radio.
# Click a card to select. The hidden radio holds the
# state value for the step2_btn click handler.
step2_arc_html = gr.HTML(_arc_cards_html("purpose"))
oarc = gr.Radio(
["money", "love", "purpose", "health"],
label="",
value="purpose",
elem_classes="hidden-radio",
elem_id="field-oarc",
)
step2_btn = gr.Button(BUTTON_TEXT["step2_next"], variant="primary")
with gr.Column(visible=False) as step3_col:
gr.Markdown("### 🌱 What's alive in you?")
with gr.Row():
with gr.Column(scale=1):
oavoid = gr.Textbox(
label="Avoiding",
lines=2,
placeholder=PLACEHOLDERS["avoiding"],
elem_id="field-oavoid",
)
gr.HTML(chip_html(EXAMPLES["avoiding"], "field-oavoid"))
with gr.Column(scale=1):
ofraid = gr.Textbox(
label="Afraid won't happen",
lines=2,
placeholder=PLACEHOLDERS["afraid"],
elem_id="field-ofraid",
)
gr.HTML(chip_html(EXAMPLES["afraid"], "field-ofraid"))
with gr.Row():
with gr.Column(scale=1):
odrain = gr.Textbox(
label="Draining you",
lines=2,
placeholder=PLACEHOLDERS["draining"],
elem_id="field-odrain",
)
gr.HTML(chip_html(EXAMPLES["draining"], "field-odrain"))
with gr.Column(scale=1):
omira = gr.Textbox(
label="Miraculous year",
lines=2,
placeholder=PLACEHOLDERS["miraculous"],
elem_id="field-omira",
)
gr.HTML(chip_html(EXAMPLES["miraculous"], "field-omira"))
gr.HTML(
'
a sentence is enough. you can come back and edit anytime.