Spaces:
Running on Zero
Running on Zero
File size: 25,739 Bytes
2ba4bf0 3a54499 2ba4bf0 3a54499 2ba4bf0 3a54499 2ba4bf0 3a54499 2ba4bf0 3a54499 2ba4bf0 3a54499 2ba4bf0 3a32028 7cef5fb 05737f6 3a32028 3a54499 2ba4bf0 05737f6 ea5b282 3a32028 78036d2 3a54499 2ba4bf0 3a54499 2ba4bf0 3a54499 2ba4bf0 e29af58 2ba4bf0 e29af58 2ba4bf0 e29af58 2ba4bf0 e29af58 9dcc63c 1cda206 9dcc63c e29af58 da5f47d e29af58 360edcc e29af58 2ba4bf0 e29af58 2ba4bf0 e29af58 2ba4bf0 e6f95d8 2ba4bf0 78036d2 e29af58 78036d2 2ba4bf0 3a54499 e29af58 44edefb e48ebc3 2ba4bf0 ca1f2a8 2ba4bf0 e29af58 2ba4bf0 a8bf7a4 2ba4bf0 e29af58 7cef5fb e29af58 ab0c4df 44c216d ab0c4df 2ba4bf0 55692f5 2ba4bf0 bfd58d1 e29af58 2ba4bf0 a8bf7a4 e29af58 2ba4bf0 1c8a58d 74d0925 e29af58 99f710e 2ba4bf0 8183336 2ba4bf0 67478d3 7896071 e48ebc3 67478d3 2ba4bf0 e29af58 6150e0e 2ba4bf0 e29af58 d468ab6 e6f95d8 e29af58 2ba4bf0 e29af58 2ba4bf0 e29af58 2ba4bf0 3a32028 e29af58 2ba4bf0 e29af58 2ba4bf0 e29af58 4d60faf 2ba4bf0 e29af58 b46dfc2 2ba4bf0 e29af58 2ba4bf0 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 | # UI design: the machine room
What the LTX-2.5 Studio interface is, and why each part is shaped as it is. Code:
`ltx25_studio/ui/` (`chrome.py` holds tokens, stylesheet and identity bar; `blocks.py`
holds layout and wiring; `handlers.py` holds every decision; `render.py` holds every
string a user reads; `fields.py` holds the input spec).
## Job
Practitioners spend a metered daily GPU quota on a model that makes video and sound
together. The page lets them pick what they start from and what they want back, see
exactly what the run will cost and return, press Generate, and watch the result
arrive without moving their eyes.
## Layout
At 1024 px and wider the page has two columns under a one-line identity bar.
- **The commission column.** At the top is the mode matrix: rows are what you start
from (Text, Image, Image + text, Video, Audio), and columns are what you get back
(Video + sound, Video (silent), Sound only). Below it come the purpose line and up
to three example buttons, then the selected mode's inputs: media first, each with
its one lever, then the prompt with Enhance. After those come shape, length and
Upscale, the LoRA row and Advanced.
- **The rail.** From the top it holds the monitor, its caption, the cost panel,
Generate with its reason line, the "What you got" card with its actions, the run
report and Recent runs. It is sticky at `top: 12px`. A small script sizes it: at page
scroll 0 it ends 12 px above the bottom of the window at any desktop size, and once
the page scrolls and the rail sticks it grows to the window less 24 px, so no dead
band is left under it. Its content never wraps: Gradio gives every Row child
`flex-wrap: wrap`, and a rail that wrapped sent its overflow into a second column off
the right edge, so the rail sets `nowrap` and its children never shrink. When the
content is taller than the rail, the rail scrolls inside itself with a real
scrollbar, drawn in a gutter outside the aligned right edge. A 4 px padding keeps
focus rings unclipped; negative margins keep the content edges level with the
identity bar.
- **Generate never leaves the rail.** It is sticky at both of the rail's edges, flush
with them, so nothing shows past it. A row that passes under its top edge (the cost
panel, on a short window) or its bottom edge (the report, with Generate stuck at the
top) runs into a 12 px ink fade instead of being cut.
- **The cost figure stays beside Generate on a short window.** The script fits the
monitor, the caption, the cost panel and Generate into the rail at rail scroll 0.
When they are taller than the rail, the monitor gives up height first, down to
180 px, letterboxed. If the panel still runs under Generate, the panel's figure line
stands above the button: "704 × 480, 5.0 s, needs 120 s quota" (off ZeroGPU, "on the
CPU"). It names what the run returns, as the panel's Returns row does: "1408 × 960
upscaled, 5.0 s, …" with Upscale ×2, and "Sound, 5.0 s, …" (or "Sound, the length of
your audio, …") in a sound-only mode, never the 256 × 256 picture it throws away.
When there is room to spare, the caption keeps four lines less the panel's notes, so
Generate stays where it is from mode to mode.
- **What a click changes comes into view.** Generate and Show scroll the rail as little
as it takes to show the monitor; when a run ends, the head of its report (the Done
card's head, or a failure's headline and next step) is brought into view clear of
Generate.
Below 1024 px the page is one column. The inputs come first, then the cost panel,
monitor and report. A fixed bottom bar holds one short line (the figure line above, or
why Generate is off: "Needs a prompt", "Won't run: 2 problems (width, frames)") and the
same Generate button, restyled. There is never a second Generate in the DOM. A control
reached by Tab stops above the bar, never under it: the page holds back the bar's
height when it scrolls. Pressing
Generate or Show on a narrow screen scrolls the monitor into view; Restore settings
brings the purpose line, which names the restored mode, into view; and while the
monitor shows a sample a "See an example output" button under the purpose line jumps
to it. The same button, at every width, offers the selected mode's sample over a run
of another mode (see the monitor, below).
## The matrix
The matrix is the existing mode `gr.Radio`, which stays parameter 0 of `/on_generate`.
CSS grid rules generated from the registry place each choice in its cell:
- the row comes from the inputs the mode requires;
- the column comes from the tracks it exports;
- the small corner number comes from registry order. It is an ID for bug reports, not
a label, and it is generated content with empty alternative text, so it is not read
as part of the cell's name.
A `gr.HTML` frame behind the radio draws the axis headers, the four inert empty cells
and the two column notes. The headers and empty cells are hidden from assistive tech
(each cell's own name already says what it starts from and returns); the column notes
are not, and each cell of a noted column is described by its note
(`aria-describedby`). The cost marker is a tungsten underline on "Sound only", the
column that pays for a thrown-away video.
The eleven radios share one `name`, so the matrix is one Tab stop. A small script
makes the arrow keys move by the grid's geometry. A mode has one name everywhere,
the registry's `label`: the cell, the purpose line, the cost panel's title, the
monitor caption, the status line and Recent runs.
## What you see is what runs
One predicate decides what each mode shows and what it requires:
- a field is shown exactly when `modes.accepts(spec, kind)`;
- a field is marked required exactly when `modes.requires(spec, kind)`.
This is the predicate `generate.scope_request_to_mode` scopes with.
**Media order.** The media inputs are built in one order derived from the registry
(`handlers.media_order`): in every mode the inputs it requires come before the ones it
may take, so the first media input a mode shows is one it needs (Audio to video asks
for its audio, then offers an optional first-frame image). DOM order is visual order
and focus order; no CSS reorders them. A registry no single order could satisfy fails
at build time.
**Mode 11's help.** Under Audio to video's audio, the line says speech is not
lip-synced and where a speaking face is made. Under its optional first-frame image,
above the prompt, the line reads:
"With a speech recording and no first-frame picture, some seeds come out as a black-and-white period film: add “in colour” to the prompt, or give a first-frame picture."
The seed decides it, not how old the recording sounds. No other mode says either.
**Parking.** When the mode changes, the value of every field the new mode does not use
is parked: it moves into a session `gr.State`, and the widget goes back to its default.
The value comes back when a mode that uses it is selected (`handlers.mode_switch`).
This covers the prompt, Enhance, media, the change level, the decoder, and the size
and length fields a mode hides (width and height in the sound-only modes, the shortest
and longest seconds where an input sets the length). So a UI run never submits a
hidden value, and the backend never has to say "an image was supplied … ignored" about
something the user cannot see. API callers still get the backend's scoping and its
notes.
**Restore settings** runs the same switch against the mode actually left, then writes
the restored run's own settings, in one step (a second step chained after it would race
the radio's own change event). What the restored mode does not take is parked like any
other switch. Its media are not restored.
**Length.** "Match my clip" writes a clip's frame count into the frame field for the
run; a mode without a timed input gets the user's own length back, never the clip's.
A recording too short for any usable length (under nine frames at 24 fps) is refused
before the run, in the same words as at a set length: "Your audio is 0.3 s, too short
for Audio to video: the shortest recording it can use is 0.4 s." In Advanced the frame
count shows while the length is set, and the shortest and longest seconds while the
model picks it; never both. The length slider steps by 0.1 s.
**Levers.** Every visible control changes what reaches the pipeline (a test flips each
one, in every mode, with Upscale on and off).
- Video to video is a variation of the user's clip: it shows "How much to change your
clip" (A little / Moderately / A lot, default A lot), writing the backend's own
levels to `noise_scale`; the prompt steers the result only at A lot. Its length is
always its clip's, so it offers no length choice.
- Audio to sound shows "How much to change your sound" (four choices, the same field).
- The clip-strength slider shows only where a video condition reads it; with today's
registry that is no mode, and its API slot stays.
- The decoder choice reads Auto (the default, the vendor's: the diffusion decoder on an
NVIDIA GPU that can run it, the standard decoder elsewhere), Steadier (diffusion
decoder) and Sharper (standard decoder), named by what a user sees: on the Space the same
run through both decoders gives the same scene, the diffusion decoder a little softer and
steadier from frame to frame, the standard decoder sharper frame by frame with more
shimmer.
- While Upscale ×2 is on, the decoder choice cannot be changed: stage 2 always finishes
with the diffusion decoder, and the line under the choice says so.
Some fields keep their API slot but show nothing:
- the negative prompt (guidance is fixed at 1.0);
- the shot-list `conditions` (a row with text is refused before every run);
- `noise_scale` itself, which the change choices write.
Some modes pin their values. Their pinned values are never written into the user's
fields. The sound-only modes show a read-only line, "Renders at 256 × 256 with no
upscale", in place of the shape controls. A size no preset matches checks no Shape
chip.
## The rail
**The monitor** is always dark and 16:9. It shows one player, chosen by what the run
exported, so joint modes never show one file twice. Its contents depend on the state:
- **Idle:** the selected mode's sample output from the manifest, captioned "Example
output, not your run". If there is no sample, a designed idle frame names the mode,
captioned "Ready. Nothing is spent until you press Generate." on ZeroGPU and "Ready.
Nothing runs until you press Generate." elsewhere.
- **During a run:** the phase-labelled progress (`show_progress_on`).
- **After a run:** that run's result, captioned with its own mode (the one that ran,
even if another was selected while it ran) and seed. It stays on screen when the
mode changes.
- **Shown from Recent runs:** an earlier run's own file, captioned "Earlier run".
- **A sample over a run:** while the monitor holds a run (yours or an earlier one) of
another mode than the selected one, and that mode has a sample, the button under the
purpose line reads "See an example of Audio to audio" at every width (class
`mr-over-run`). It puts that sample on the monitor with its usual caption, and later
switches follow with their own samples; the run is kept, and the same button reads
"Back to your run" and puts it back, while its file is still on disk. Below 1024 px
the button also scrolls to the monitor.
**The cost panel** is the signature element. It is a labelled grid with these rows:
- Renders
- Returns
- Reserves
- Needs (quota free to start)
- Billed
- LoRA
Above the grid are cost lamps that light only when they are true; a request that would
be refused lights none. The row is a named group ("Costs that apply") and an unlit lamp
is hidden from assistive tech, so a lamp's state is not in colour alone. The figures
come from these sources:
- **Reserves:** `zerogpu.estimate_duration` for the same request, at its size and
length, with each extra named with its seconds.
- **Needs:** the reservation times the quota multiplier.
- **Renders and Returns:** the size and length come from the request that
`generate.prepare_request` scopes. A clip mode with no clip loaded yet says "the
length of your clip".
A request that would be refused shows "Won't run", lists every size and length problem
with the nearest values that run, and shows no figure. The lamp words are:
- "Upscale +N s"
- "Enhance +N s"
- "LoRA +N s"
- "Video thrown away"
- "Audio encode"
The cost words at the point of choice come from the same estimator: the Upscale line
says how many seconds it adds at the default size and length, and that the cost panel
shows what it adds when it is on; the Enhance line says what it reserves and that a
cold start can take about 2 minutes (it mentions an image only where the mode takes
one).
**Off ZeroGPU there is no meter, and the page names none.** The platform is resolved as
`app.py` resolves it (`device.current()`, read by `handlers.run_platform`). Where the app
is not on ZeroGPU (a Mac, the CPU, a CUDA box of one's own):
- the Reserves, Needs and Billed rows give way to one row, "Runs: on the CPU; nothing is
metered" (or "on this Mac's GPU", "on the GPU": the Done card's device words), and the
lamps carry no seconds;
- "How quota works" is not shown; the column notes, the Enhance, Upscale and LoRA lines,
the phone bar's line ("704 × 480, 5.0 s, on the CPU") and the refused panel say what
happens without a meter;
- a failure card has no quota line: a request refused before running says "Nothing
ran.", any other card only its step; the cards about the platform's quota and its
per-run limit, which a local run cannot raise, fall back to the generic card; the lost
run and the empty-file cards have no billing sentence.
- Upscale ×2 where this machine cannot run it for the request (the backend's own gate,
`generate._checked_stage_2_size`: off CUDA, above a small decoder size) is parked:
unticked, disabled, and its line says "Upscale ×2 needs a CUDA GPU; this machine runs on
the CPU." While parked its label is the bare "Upscale ×2", with no returned size, and
the panel shows no Upscale lamp. It frees itself at a size the backend accepts, and the
size and the lamp come back. The review step writes the label, with the parking.
On ZeroGPU every one of these sentences is as above.
**Generate** is disabled whenever the form would be refused. The line under it uses
the backend's own refusal words, from `generate.prepare_request`. Generate is also
disabled while a run is in flight. The click runs three steps:
1. A start step disables Generate and clears the monitor.
2. `/on_generate` runs, with its inputs and outputs frozen.
3. A final step re-enables Generate and puts the result on the monitor.
Gradio 6.24's page runs a step's `.then` listeners only when the step completes. When
the server fails it (the function raised, or Gradio could not process what it returned,
such as a result file it will not serve) or the page cannot apply its outputs, the page
runs the `.failure` listeners alone. So the final step is `.then`, and a failure step of
its own is wired as `.failure`, after `/on_generate` and after the final step too. The
failure step sends no file, so it cannot fail the way the step before it did. It brings
Generate back, puts the monitor back to its idle frame and shows a card: for a run that
finished, "The run finished, but its result could not be shown", what the run used (on
ZeroGPU, that it is billed), Press Generate again, and the server's own message as its
Detail. Gradio tells the page only "Error", so the app keeps that message per session
from the step that failed. A request that would be refused never reaches `generate()`,
so its red panel can truthfully say "Nothing ran. No GPU time was used."
The failure step reads the run's own inputs, so when Gradio could not prepare them (an
upload its cache clean-up removed after six hours) it fails the same way. A last
failure listener after it reads no input at all and sends no file: it brings Generate
back, puts the monitor back to its idle frame and shows "Your inputs could not be read"
("Nothing ran", the upload to add again, Gradio's message as its Detail). Typed number
fields declare no range, because Gradio refuses a value outside one before any handler
runs; the app's own gate refuses a seed below −1 in the page's words. Sliders keep
their ranges.
**The report** is the `/on_generate` Markdown, in `#run-status`. That region is in the
page from the first paint (empty, visually hidden), with `role="status"`, so its first
message is announced; it turns assertive on failure. On success it carries a "Done"
line (read, not shown), the backend's notes as plain text (the UI shows them as they
come and does not reword them) and a collapsed Diagnostics block with
`record.diagnostics` (VRAM, partition, run folder) and the mode id. A "What you got"
card above it is built from the run record:
- mode
- size and upscale
- length, and where it came from: a length the model picked reads "chosen by the
model" only strictly inside the shortest and longest the user allowed; at either end
(where the pipeline may have raised or lowered the model's own figure) it reads "the
shortest you allowed" or "the longest you allowed", and the run's note says what the
model chose
- the change level, named with its choice (Video to video, Audio to sound)
- seed
- LoRA strengths
- the decoder that ran, by its choice's name (Steadier (diffusion decoder), Sharper
(standard decoder))
- time taken, labelled by the device that ran it; on ZeroGPU, with the quota it drew;
a run under half a second took "under 1 s", never "0 s"
Reuse seed and Use this prompt close the card, and so does a quiet "Download the sound
(WAV)" when the run returned its picture and its sound as two files (a video with
sound): the sound track alone, for a voice or ambience to use elsewhere. A sound-only
or silent run, or one file carrying both tracks, offers none; the player's own
download is the video, with its sound.
Use this prompt shows when the prompt the model was sent differs from the one typed
(it was enhanced). It writes that prompt into the prompt box and turns Enhance off in
the same step, so the next run sends it as it is, and then reads "Copied to your
prompt; Enhance is off". In a mode that takes no prompt it writes nothing hidden: the
prompt and Enhance are parked and come back with the prompt box.
A failure has a plain category headline, a quota line, one next step and the verbatim
detail in a `<details>`. The card belongs to its run: a switch to another mode, Show,
a Restore, or a change to a control its step names (Enhance for the enhancer card,
Upscale, Enhance or LoRA for the quota card, size, length or Upscale for a timeout or
memory card, any field for a refused input) turns it into one line, "Last run: Text to
video, 08:05. The prompt enhancer is unavailable."; a card whose step is to press
Generate again stays until the next run. Categories arrive as strings from
`errors.categorise`; each has its own card (not enough quota, a run longer than the
platform allows, no GPU free in time, out of GPU time, out of memory, an input
problem, an adapter that does not fit, the enhancer unavailable, a bug), and a
category the UI has never seen gets a generic one. A queue timeout reads as "No GPU
was free in time", never as running out of GPU time.
**Recent runs** keeps the last six runs of the session, each with "Show" (while its
file is still on disk), "Restore settings" and "Reuse seed". Restore says what it did in
a quiet line under the heading, until the next run: "Settings from 08:06 restored; the
seed is random again, as it was for that run. Your current audio stays as it is." (or
"with that run's seed, 42" for a fixed seed).
## LoRA
The LoRA row is an accordion whose label is the live state: "LoRA: none. Add an
adapter" or "LoRA: 2 adapters at 0.8 and 1.0". Inside it are two routes:
- a Hub repo-id box, which accepts Hub ids only, with "Check and add";
- an upload, which is copied into an app-owned folder before it is checked, because
`delete_cache` prunes Gradio's upload cache.
Adapters are staged with `lora.staged_entry` at strength 1.0 and de-duplicated by
content key. The bay pre-builds three rows, each with the adapter's name, a strength
slider and Remove. A row's slider takes its range from `lora.staging` (more than 0, at
most its `MAX_WEIGHT`) when the row is shown, so the LoRA package stays lazy until an
adapter is checked. The strength reaches the run from the pointer (the slider's
`release`) and from the keyboard (its `input`: arrow keys send nothing else); the value
`input` sends is held to the slider's range as the page holds it, because a number typed
into its box passes through values outside it. An accepted adapter gets a roll-edged
card. A rejected one gets a cut card with a plain headline, one next step for its kind
("Use an adapter made for LTX-2.5.", "Download the file again, then upload it.", ...),
on ZeroGPU "Nothing was spent.", and the validator's message, with a server path to the
file shown as its name. At 560 px and below a row stacks: name, strength, Remove.
## Visual system
The tokens are dark under both OS schemes. Gradio's theme variables are pinned to
them with `!important` from the identity bar's `head=`, because Gradio's own sheet
loads after ours. Where a Gradio rule out-ranks a class (its `h1`–`h6` reset is
`(0,1,1)`), our selectors carry an ID.
| token | hex | role |
|---|---|---|
| ink | `#12161B` | page ground |
| slate | `#1C232B` | the commission panel, the cost panel, the report |
| slate-2 | `#242D37` | raised: selected cell, secondary buttons |
| well | `#0E1216` | recessed: inputs, drop zones, the monitor |
| line | `#39434F` | hairlines |
| line-strong | `#66727F` | control edges: input borders (3.8:1 on the well), a slider's unfilled track (3.2:1 on slate) |
| paper | `#E9ECEF` | text, the focus ring, neutral accents, a slider's fill and thumb |
| dust | `#9AA6B2` | secondary and help text |
| tungsten | `#F2A33C` | cost only: lamps, the reserve and quota figures, the Generate fill |
| cut | `#E5484D` / text `#FF8A8E` | failure only |
| roll | `#3FBF7F` | accepted only: staged adapters, a file in a drop zone, a finished run |
**Type:**
- Chakra Petch 600 for the wordmark (20), matrix headers (14), panel titles (16),
Generate (16) and lamps (12).
- Spline Sans for prose (14/21; help text 13/19) and for figures inside sentences, with
tabular figures. Help lines are capped at `70ch`, which at 13 px is about 89
characters a line, not 70 (review round 3, P7; not changed this round).
- Spline Sans Mono 500, with tabular figures, for number inputs and the two tungsten
figures.
**Components:**
- **One button family.** Primary is Generate only. Secondary is a slate-2 fill with a
line border. Quiet buttons are underlined text. All of them use the small size.
- **Native controls** are drawn from the tokens: the slider's track is paper against
line-strong (4.1:1) with a paper thumb in an ink ring; a checked box carries an ink
tick, a radio an ink dot; accordions use the same chevron as "How quota works".
- **One focus ring:** 2 px paper with a 2 px offset.
- **Radii:** panels 10, controls 6, lamps 3.
- **Motion:** state changes only, and none under `prefers-reduced-motion`.
- **Footer:** Gradio's hidden footer controls stay hidden ("Stop Recording" is never
shown), and its run-history link, which competes with Recent runs, is hidden.
- **Players work without a hovering pointer.** The monitor's video player and a loaded
clip's preview show their control bar to keyboard focus, while the video is paused and
on a touch screen, in the well colour. Play is named "Play" or "Pause" and full screen
"Full screen", and only Enter and Space act on them, so Tab moves on without starting
or stopping a clip. On a phone a media zone's own buttons, a loaded audio's controls and
a checkbox's label are 44 px targets like every other control.
## Showcase
`LTX25_EXAMPLES_DIR` (default `examples/`) may hold a `manifest.json` (schema in
`ui/showcase.py`). Each mode can have examples and one sample output:
- An example has a label, a prompt, media paths and settings (shape or exact size,
seconds, upscale, enhance, `auto_duration`, seed, and `noise` naming a change
choice). "Try an example" fills the form and runs nothing.
- A sample output has its file, caption, settings and seed. Its settings may be free
text, or a mapping (size, seconds, upscale, enhance, `auto_duration`) that the
caption says in words. The shipped captions name the example each sample was made
from and say it was made earlier, with that example's inputs and seed: the samples
were made on one machine, and another (the Space) gives another take for the same
seed, so no caption promises a repeat. The lengths they state are the files' own.
Entries that name a missing file, or a path outside the folder, are skipped. With no
manifest, there is no example row and the monitor shows its idle frame. A manifest
with entries for all eleven modes needs no code change.
## Contracts
- **`/on_generate`:** parameter 0 is the mode radio, then `FIELD_KEYS` in order, which
is append-only with unchanged component classes. It returns `[Video, Audio,
Markdown]`.
- **`/on_validate_lora`:** its inputs and outputs are unchanged.
- **Other events:** every other event is `api_visibility="private"`.
- **Progress:** no event builds `gr.Progress(track_tqdm=True)`, which patches tqdm for
the whole process.
|