Update to 0.23.0

README.md

@@ -10,7 +10,7 @@ app_file: space.py
 ---
 
 # `gradio_rerun`
-<a href="https://pypi.org/project/gradio_rerun/" target="_blank"><img alt="PyPI - Version" src="https://img.shields.io/pypi/v/gradio_rerun"></a> <a href="https://github.com/radames/gradio-rerun-viewer/issues" target="_blank"><img alt="Static Badge" src="https://img.shields.io/badge/Issues-white?logo=github&logoColor=black"></a> 
+<a href="https://pypi.org/project/gradio_rerun/" target="_blank"><img alt="PyPI - Version" src="https://img.shields.io/pypi/v/gradio_rerun"></a> <a href="https://github.com/rerun-io/gradio-rerun-viewer/issues" target="_blank"><img alt="Static Badge" src="https://img.shields.io/badge/Issues-white?logo=github&logoColor=black"></a> <a href="https://huggingface.co/spaces/rerun/gradio-rerun-viewer/discussions" target="_blank"><img alt="Static Badge" src="https://img.shields.io/badge/%F0%9F%A4%97%20Discuss-%23097EFF?style=flat&logoColor=black"></a>
 
 Rerun viewer with Gradio
 
@@ -23,22 +23,37 @@ pip install gradio_rerun
 ## Usage
 
 ```python
-import cv2
+"""
+Demonstrates integrating Rerun visualization with Gradio.
+
+Provides example implementations of data streaming, keypoint annotation, and dynamic
+visualization across multiple Gradio tabs using Rerun's recording and visualization capabilities.
+"""
+
+import math
 import os
 import tempfile
 import time
+import uuid
 
+import cv2
 import gradio as gr
-from gradio_rerun import Rerun
-
 import rerun as rr
 import rerun.blueprint as rrb
-
 from color_grid import build_color_grid
+from gradio_rerun import Rerun
+from gradio_rerun.events import (
+    SelectionChange,
+    TimelineChange,
+    TimeUpdate,
+)
+
 
-# NOTE: Functions that work with Rerun should be decorated with `@rr.thread_local_stream`.
-# This decorator creates a generator-aware thread-local context so that rerun log calls
-# across multiple workers stay isolated.
+# Whenever we need a recording, we construct a new recording stream.
+# As long as the app and recording IDs remain the same, the data
+# will be merged by the Viewer.
+def get_recording(recording_id: str) -> rr.RecordingStream:
+    return rr.RecordingStream(application_id="rerun_example_gradio", recording_id=recording_id)
 
 
 # A task can directly log to a binary stream, which is routed to the embedded viewer.
@@ -46,9 +61,10 @@ from color_grid import build_color_grid
 #
 # This is the preferred way to work with Rerun in Gradio since your data can be immediately and
 # incrementally seen by the viewer. Also, there are no ephemeral RRDs to cleanup or manage.
-@rr.thread_local_stream("rerun_example_streaming_blur")
-def streaming_repeated_blur(img):
-    stream = rr.binary_stream()
+def streaming_repeated_blur(recording_id: str, img):
+    # Here we get a recording using the provided recording id.
+    rec = get_recording(recording_id)
+    stream = rec.binary_stream()
 
     if img is None:
         raise gr.Error("Must provide an image to blur.")
@@ -61,23 +77,19 @@ def streaming_repeated_blur(img):
         collapse_panels=True,
     )
 
-    rr.send_blueprint(blueprint)
-
-    rr.set_time_sequence("iteration", 0)
-
-    rr.log("image/original", rr.Image(img))
+    rec.send_blueprint(blueprint)
+    rec.set_time("iteration", sequence=0)
+    rec.log("image/original", rr.Image(img))
     yield stream.read()
 
     blur = img
-
     for i in range(100):
-        rr.set_time_sequence("iteration", i)
+        rec.set_time("iteration", sequence=i)
 
         # Pretend blurring takes a while so we can see streaming in action.
         time.sleep(0.1)
         blur = cv2.GaussianBlur(blur, (5, 5), 0)
-
-        rr.log("image/blurred", rr.Image(blur))
+        rec.log("image/blurred", rr.Image(blur))
 
         # Each time we yield bytes from the stream back to Gradio, they
         # are incrementally sent to the viewer. Make sure to yield any time
@@ -85,6 +97,87 @@ def streaming_repeated_blur(img):
         yield stream.read()
 
 
+# In this example the user is able to add keypoints to an image visualized in Rerun.
+# These keypoints are stored in the global state, we use the session id to keep track of which keypoints belong
+# to a specific session (https://www.gradio.app/guides/state-in-blocks).
+#
+# The current session can be obtained by adding a parameter of type `gradio.Request` to your event listener functions.
+Keypoint = tuple[float, float]
+keypoints_per_session_per_sequence_index: dict[str, dict[int, list[Keypoint]]] = {}
+
+
+def get_keypoints_for_user_at_sequence_index(request: gr.Request, sequence: int) -> list[Keypoint]:
+    per_sequence = keypoints_per_session_per_sequence_index[request.session_hash]
+    if sequence not in per_sequence:
+        per_sequence[sequence] = []
+
+    return per_sequence[sequence]
+
+
+def initialize_instance(request: gr.Request) -> None:
+    keypoints_per_session_per_sequence_index[request.session_hash] = {}
+
+
+def cleanup_instance(request: gr.Request) -> None:
+    if request.session_hash in keypoints_per_session_per_sequence_index:
+        del keypoints_per_session_per_sequence_index[request.session_hash]
+
+
+# In this function, the `request` and `evt` parameters will be automatically injected by Gradio when this
+# event listener is fired.
+#
+# `SelectionChange` is a subclass of `EventData`: https://www.gradio.app/docs/gradio/eventdata
+# `gr.Request`: https://www.gradio.app/main/docs/gradio/request
+def register_keypoint(
+    active_recording_id: str,
+    current_timeline: str,
+    current_time: float,
+    request: gr.Request,
+    change: SelectionChange,
+):
+    if active_recording_id == "":
+        return
+
+    if current_timeline != "iteration":
+        return
+
+    evt = change.payload
+
+    # We can only log a keypoint if the user selected only a single item.
+    if len(evt.items) != 1:
+        return
+    item = evt.items[0]
+
+    # If the selected item isn't an entity, or we don't have its position, then bail out.
+    if item.type != "entity" or item.position is None:
+        return
+
+    # Now we can produce a valid keypoint.
+    rec = get_recording(active_recording_id)
+    stream = rec.binary_stream()
+
+    # We round `current_time` toward 0, because that gives us the sequence index
+    # that the user is currently looking at, due to the Viewer's latest-at semantics.
+    index = math.floor(current_time)
+
+    # We keep track of the keypoints per sequence index for each user manually.
+    keypoints = get_keypoints_for_user_at_sequence_index(request, index)
+    keypoints.append(item.position[0:2])
+
+    rec.set_time("iteration", sequence=index)
+    rec.log(f"{item.entity_path}/keypoint", rr.Points2D(keypoints, radii=2))
+
+    yield stream.read()
+
+
+def track_current_time(evt: TimeUpdate):
+    return evt.payload.time
+
+
+def track_current_timeline_and_time(evt: TimelineChange):
+    return evt.payload.timeline, evt.payload.time
+
+
 # However, if you have a workflow that creates an RRD file instead, you can still send it
 # directly to the viewer by simply returning the path to the RRD file.
 #
@@ -92,12 +185,15 @@ def streaming_repeated_blur(img):
 # be easily modified to stream data directly via Gradio.
 #
 # In this case you may want to clean up the RRD file after it's sent to the viewer so that you
-# don't accumulate too many  temporary files.
+# don't accumulate too many temporary files.
 @rr.thread_local_stream("rerun_example_cube_rrd")
 def create_cube_rrd(x, y, z, pending_cleanup):
     cube = build_color_grid(int(x), int(y), int(z), twist=0)
     rr.log("cube", rr.Points3D(cube.positions, colors=cube.colors, radii=0.5))
 
+    # Simulate delay
+    time.sleep(x / 10)
+
     # We eventually want to clean up the RRD file after it's sent to the viewer, so tracking
     # any pending files to be cleaned up when the state is deleted.
     temp = tempfile.NamedTemporaryFile(prefix="cube_", suffix=".rrd", delete=False)
@@ -111,7 +207,7 @@ def create_cube_rrd(x, y, z, pending_cleanup):
     return temp.name
 
 
-def cleanup_cube_rrds(pending_cleanup):
+def cleanup_cube_rrds(pending_cleanup: list[str]) -> None:
     for f in pending_cleanup:
         os.unlink(f)
 
@@ -122,6 +218,7 @@ with gr.Blocks() as demo:
             img = gr.Image(interactive=True, label="Image")
             with gr.Column():
                 stream_blur = gr.Button("Stream Repeated Blur")
+
         with gr.Row():
             viewer = Rerun(
                 streaming=True,
@@ -131,22 +228,35 @@ with gr.Blocks() as demo:
                     "selection": "hidden",
                 },
             )
-        stream_blur.click(streaming_repeated_blur, inputs=[img], outputs=[viewer])
 
-    with gr.Tab("Dynamic RRD"):
-        pending_cleanup = gr.State(
-            [], time_to_live=10, delete_callback=cleanup_cube_rrds
+        # We make a new recording id, and store it in a Gradio's session state.
+        recording_id = gr.State(uuid.uuid4())
+
+        # Also store the current timeline and time of the viewer in the session state.
+        current_timeline = gr.State("")
+        current_time = gr.State(0.0)
+
+        # When registering the event listeners, we pass the `recording_id` in as input in order to create
+        # a recording stream using that id.
+        stream_blur.click(
+            # Using the `viewer` as an output allows us to stream data to it by yielding bytes from the callback.
+            streaming_repeated_blur,
+            inputs=[recording_id, img],
+            outputs=[viewer],
         )
+        viewer.selection_change(
+            register_keypoint,
+            inputs=[recording_id, current_timeline, current_time],
+            outputs=[viewer],
+        )
+        viewer.time_update(track_current_time, outputs=[current_time])
+        viewer.timeline_change(track_current_timeline_and_time, outputs=[current_timeline, current_time])
+    with gr.Tab("Dynamic RRD"):
+        pending_cleanup = gr.State([], time_to_live=10, delete_callback=cleanup_cube_rrds)
         with gr.Row():
-            x_count = gr.Number(
-                minimum=1, maximum=10, value=5, precision=0, label="X Count"
-            )
-            y_count = gr.Number(
-                minimum=1, maximum=10, value=5, precision=0, label="Y Count"
-            )
-            z_count = gr.Number(
-                minimum=1, maximum=10, value=5, precision=0, label="Z Count"
-            )
+            x_count = gr.Number(minimum=1, maximum=10, value=5, precision=0, label="X Count")
+            y_count = gr.Number(minimum=1, maximum=10, value=5, precision=0, label="Y Count")
+            z_count = gr.Number(minimum=1, maximum=10, value=5, precision=0, label="Z Count")
         with gr.Row():
             create_rrd = gr.Button("Create RRD")
         with gr.Row():
@@ -186,6 +296,8 @@ with gr.Blocks() as demo:
                 },
             )
         choose_rrd.change(lambda x: x, inputs=[choose_rrd], outputs=[viewer])
+    demo.load(initialize_instance)
+    demo.close(cleanup_instance)
 
 
 if __name__ == "__main__":
@@ -216,13 +328,13 @@ list[pathlib.Path | str]
     | pathlib.Path
     | str
     | bytes
-    | Callable
+    | collections.abc.Callable
     | None
 ```
 
 </td>
 <td align="left"><code>None</code></td>
-<td align="left">Takes a singular or list of RRD resources. Each RRD can be a Path, a string containing a url, or a binary blob containing encoded RRD data. If callable, the function will be called whenever the app loads to set the initial value of the component.</td>
+<td align="left">Takes a singular or list of RRD resources. Each RRD can be a Path, a string containing a url,</td>
 </tr>
 
 <tr>
@@ -235,7 +347,7 @@ str | None
 
 </td>
 <td align="left"><code>None</code></td>
-<td align="left">The label for this component. Appears above the component and is also used as the header if there are a table of examples for this component. If None and used in a `gr.Interface`, the label will be the name of the parameter this component is assigned to.</td>
+<td align="left">The label for this component. Appears above the component and is also used as the header if there</td>
 </tr>
 
 <tr>
@@ -248,7 +360,7 @@ float | None
 
 </td>
 <td align="left"><code>None</code></td>
-<td align="left">If `value` is a callable, run the function 'every' number of seconds while the client connection is open. Has no effect otherwise. Queue must be enabled. The event can be accessed (e.g. to cancel it) via this component's .load_event attribute.</td>
+<td align="left">If `value` is a callable, run the function 'every' number of seconds while the client connection is</td>
 </tr>
 
 <tr>
@@ -274,7 +386,7 @@ bool
 
 </td>
 <td align="left"><code>True</code></td>
-<td align="left">If True, will place the component in a container - providing some extra padding around the border.</td>
+<td align="left">If True, will place the component in a container providing some extra padding around the border.</td>
 </tr>
 
 <tr>
@@ -287,7 +399,7 @@ int | None
 
 </td>
 <td align="left"><code>None</code></td>
-<td align="left">relative size compared to adjacent Components. For example if Components A and B are in a Row, and A has scale=2, and B has scale=1, A will be twice as wide as B. Should be an integer. scale applies in Rows, and to top-level Components in Blocks where fill_height=True.</td>
+<td align="left">relative size compared to adjacent Components.</td>
 </tr>
 
 <tr>
@@ -300,7 +412,7 @@ int
 
 </td>
 <td align="left"><code>160</code></td>
-<td align="left">minimum pixel width, will wrap if not sufficient screen space to satisfy this value. If a certain scale value results in this Component being narrower than min_width, the min_width parameter will be respected first.</td>
+<td align="left">minimum pixel width, will wrap if not sufficient screen space to satisfy this value.</td>
 </tr>
 
 <tr>
@@ -313,7 +425,7 @@ int | str
 
 </td>
 <td align="left"><code>640</code></td>
-<td align="left">height of component in pixels. If a string is provided, will be interpreted as a CSS value. If None, will be set to 640px.</td>
+<td align="left">height of component in pixels. If a string is provided, will be interpreted as a CSS value.</td>
 </tr>
 
 <tr>
@@ -339,7 +451,7 @@ bool
 
 </td>
 <td align="left"><code>False</code></td>
-<td align="left">If True, the data should be incrementally yielded from the source as `bytes` returned by calling `.read()` on an `rr.binary_stream()`</td>
+<td align="left">If True, the data should be incrementally yielded from the source as `bytes` returned by</td>
 </tr>
 
 <tr>
@@ -352,7 +464,7 @@ str | None
 
 </td>
 <td align="left"><code>None</code></td>
-<td align="left">An optional string that is assigned as the id of this component in the HTML DOM. Can be used for targeting CSS styles.</td>
+<td align="left">An optional string that is assigned as the id of this component in the HTML DOM.</td>
 </tr>
 
 <tr>
@@ -365,7 +477,7 @@ list[str] | str | None
 
 </td>
 <td align="left"><code>None</code></td>
-<td align="left">An optional list of strings that are assigned as the classes of this component in the HTML DOM. Can be used for targeting CSS styles.</td>
+<td align="left">An optional list of strings that are assigned as the classes of this component in</td>
 </tr>
 
 <tr>
@@ -378,7 +490,7 @@ bool
 
 </td>
 <td align="left"><code>True</code></td>
-<td align="left">If False, component will not render be rendered in the Blocks context. Should be used if the intention is to assign event listeners now but render the component later.</td>
+<td align="left">If False, component will not render be rendered in the Blocks context.</td>
 </tr>
 
 <tr>
@@ -386,16 +498,26 @@ bool
 <td align="left" style="width: 25%;">
 
 ```python
-dict[str, Any] | None
+dict[str, typing.Any] | None
 ```
 
 </td>
 <td align="left"><code>None</code></td>
-<td align="left">Force viewer panels to a specific state. Any panels set cannot be toggled by the user in the viewer. Panel names are "top", "blueprint", "selection", and "time". States are "hidden", "collapsed", and "expanded".</td>
+<td align="left">Force viewer panels to a specific state.</td>
 </tr>
 </tbody></table>
 
 
+### Events
+
+| name               | description                                                                                                         |
+| :----------------- | :------------------------------------------------------------------------------------------------------------------ |
+| `play`             | Fired when timeline playback starts. Callback should accept a parameter of type `gradio_rerun.events.Play`          |
+| `pause`            | Fired when timeline pauseback starts. Callback should accept a parameter of type `gradio_rerun.events.Pause`        |
+| `time_update`      | Fired when time updates. Callback should accept a parameter of type `gradio_rerun.events.TimeUpdate`.               |
+| `timeline_change`  | Fired when a timeline is selected. Callback should accept a parameter of type `gradio_rerun.events.TimelineChange`. |
+| `selection_change` | Fired when the selection changes. Callback should accept a parameter of type `gradio_rerun.events.SelectionChange`. |
+
 
 
 ### User function
@@ -407,8 +529,8 @@ The impact on the users predict function varies depending on whether the compone
 
 The code snippet below is accurate in cases where the component is used as both an input and an output.
 
-- **As output:** Is passed, a RerunData object.
-- **As input:** Should return, expects.
+- **As output:** Is passed, a `RerunData` object.
+- **As input:** Should return, the value to send over to the Rerun viewer on the front-end.
 
  ```python
  def predict(
@@ -421,5 +543,5 @@ The code snippet below is accurate in cases where the component is used as both
 ## `RerunData`
 ```python
 class RerunData(GradioRootModel):
-    root: list[FileData | str]
+    root: Sequence[FileData | Path | str] | None
 ```

app.py

@@ -1,19 +1,36 @@
-import cv2
+"""
+Demonstrates integrating Rerun visualization with Gradio.
+
+Provides example implementations of data streaming, keypoint annotation, and dynamic
+visualization across multiple Gradio tabs using Rerun's recording and visualization capabilities.
+"""
+
+import math
 import os
 import tempfile
 import time
+import uuid
 
+import cv2
 import gradio as gr
-from gradio_rerun import Rerun
-
 import rerun as rr
 import rerun.blueprint as rrb
-
 from color_grid import build_color_grid
+from gradio_rerun import Rerun
+from gradio_rerun.events import (
+    SelectionChange,
+    TimelineChange,
+    TimeUpdate,
+)
+
 
-# NOTE: Functions that work with Rerun should be decorated with `@rr.thread_local_stream`.
-# This decorator creates a generator-aware thread-local context so that rerun log calls
-# across multiple workers stay isolated.
+# Whenever we need a recording, we construct a new recording stream.
+# As long as the app and recording IDs remain the same, the data
+# will be merged by the Viewer.
+def get_recording(recording_id: str) -> rr.RecordingStream:
+    return rr.RecordingStream(
+        application_id="rerun_example_gradio", recording_id=recording_id
+    )
 
 
 # A task can directly log to a binary stream, which is routed to the embedded viewer.
@@ -21,9 +38,10 @@ from color_grid import build_color_grid
 #
 # This is the preferred way to work with Rerun in Gradio since your data can be immediately and
 # incrementally seen by the viewer. Also, there are no ephemeral RRDs to cleanup or manage.
-@rr.thread_local_stream("rerun_example_streaming_blur")
-def streaming_repeated_blur(img):
-    stream = rr.binary_stream()
+def streaming_repeated_blur(recording_id: str, img):
+    # Here we get a recording using the provided recording id.
+    rec = get_recording(recording_id)
+    stream = rec.binary_stream()
 
     if img is None:
         raise gr.Error("Must provide an image to blur.")
@@ -36,23 +54,19 @@ def streaming_repeated_blur(img):
         collapse_panels=True,
     )
 
-    rr.send_blueprint(blueprint)
-
-    rr.set_time_sequence("iteration", 0)
-
-    rr.log("image/original", rr.Image(img))
+    rec.send_blueprint(blueprint)
+    rec.set_time("iteration", sequence=0)
+    rec.log("image/original", rr.Image(img))
     yield stream.read()
 
     blur = img
-
     for i in range(100):
-        rr.set_time_sequence("iteration", i)
+        rec.set_time("iteration", sequence=i)
 
         # Pretend blurring takes a while so we can see streaming in action.
         time.sleep(0.1)
         blur = cv2.GaussianBlur(blur, (5, 5), 0)
-
-        rr.log("image/blurred", rr.Image(blur))
+        rec.log("image/blurred", rr.Image(blur))
 
         # Each time we yield bytes from the stream back to Gradio, they
         # are incrementally sent to the viewer. Make sure to yield any time
@@ -60,6 +74,89 @@ def streaming_repeated_blur(img):
         yield stream.read()
 
 
+# In this example the user is able to add keypoints to an image visualized in Rerun.
+# These keypoints are stored in the global state, we use the session id to keep track of which keypoints belong
+# to a specific session (https://www.gradio.app/guides/state-in-blocks).
+#
+# The current session can be obtained by adding a parameter of type `gradio.Request` to your event listener functions.
+Keypoint = tuple[float, float]
+keypoints_per_session_per_sequence_index: dict[str, dict[int, list[Keypoint]]] = {}
+
+
+def get_keypoints_for_user_at_sequence_index(
+    request: gr.Request, sequence: int
+) -> list[Keypoint]:
+    per_sequence = keypoints_per_session_per_sequence_index[request.session_hash]
+    if sequence not in per_sequence:
+        per_sequence[sequence] = []
+
+    return per_sequence[sequence]
+
+
+def initialize_instance(request: gr.Request) -> None:
+    keypoints_per_session_per_sequence_index[request.session_hash] = {}
+
+
+def cleanup_instance(request: gr.Request) -> None:
+    if request.session_hash in keypoints_per_session_per_sequence_index:
+        del keypoints_per_session_per_sequence_index[request.session_hash]
+
+
+# In this function, the `request` and `evt` parameters will be automatically injected by Gradio when this
+# event listener is fired.
+#
+# `SelectionChange` is a subclass of `EventData`: https://www.gradio.app/docs/gradio/eventdata
+# `gr.Request`: https://www.gradio.app/main/docs/gradio/request
+def register_keypoint(
+    active_recording_id: str,
+    current_timeline: str,
+    current_time: float,
+    request: gr.Request,
+    change: SelectionChange,
+):
+    if active_recording_id == "":
+        return
+
+    if current_timeline != "iteration":
+        return
+
+    evt = change.payload
+
+    # We can only log a keypoint if the user selected only a single item.
+    if len(evt.items) != 1:
+        return
+    item = evt.items[0]
+
+    # If the selected item isn't an entity, or we don't have its position, then bail out.
+    if item.type != "entity" or item.position is None:
+        return
+
+    # Now we can produce a valid keypoint.
+    rec = get_recording(active_recording_id)
+    stream = rec.binary_stream()
+
+    # We round `current_time` toward 0, because that gives us the sequence index
+    # that the user is currently looking at, due to the Viewer's latest-at semantics.
+    index = math.floor(current_time)
+
+    # We keep track of the keypoints per sequence index for each user manually.
+    keypoints = get_keypoints_for_user_at_sequence_index(request, index)
+    keypoints.append(item.position[0:2])
+
+    rec.set_time("iteration", sequence=index)
+    rec.log(f"{item.entity_path}/keypoint", rr.Points2D(keypoints, radii=2))
+
+    yield stream.read()
+
+
+def track_current_time(evt: TimeUpdate):
+    return evt.payload.time
+
+
+def track_current_timeline_and_time(evt: TimelineChange):
+    return evt.payload.timeline, evt.payload.time
+
+
 # However, if you have a workflow that creates an RRD file instead, you can still send it
 # directly to the viewer by simply returning the path to the RRD file.
 #
@@ -67,12 +164,15 @@ def streaming_repeated_blur(img):
 # be easily modified to stream data directly via Gradio.
 #
 # In this case you may want to clean up the RRD file after it's sent to the viewer so that you
-# don't accumulate too many  temporary files.
+# don't accumulate too many temporary files.
 @rr.thread_local_stream("rerun_example_cube_rrd")
 def create_cube_rrd(x, y, z, pending_cleanup):
     cube = build_color_grid(int(x), int(y), int(z), twist=0)
     rr.log("cube", rr.Points3D(cube.positions, colors=cube.colors, radii=0.5))
 
+    # Simulate delay
+    time.sleep(x / 10)
+
     # We eventually want to clean up the RRD file after it's sent to the viewer, so tracking
     # any pending files to be cleaned up when the state is deleted.
     temp = tempfile.NamedTemporaryFile(prefix="cube_", suffix=".rrd", delete=False)
@@ -86,7 +186,7 @@ def create_cube_rrd(x, y, z, pending_cleanup):
     return temp.name
 
 
-def cleanup_cube_rrds(pending_cleanup):
+def cleanup_cube_rrds(pending_cleanup: list[str]) -> None:
     for f in pending_cleanup:
         os.unlink(f)
 
@@ -97,6 +197,7 @@ with gr.Blocks() as demo:
             img = gr.Image(interactive=True, label="Image")
             with gr.Column():
                 stream_blur = gr.Button("Stream Repeated Blur")
+
         with gr.Row():
             viewer = Rerun(
                 streaming=True,
@@ -106,8 +207,31 @@ with gr.Blocks() as demo:
                     "selection": "hidden",
                 },
             )
-        stream_blur.click(streaming_repeated_blur, inputs=[img], outputs=[viewer])
 
+        # We make a new recording id, and store it in a Gradio's session state.
+        recording_id = gr.State(uuid.uuid4())
+
+        # Also store the current timeline and time of the viewer in the session state.
+        current_timeline = gr.State("")
+        current_time = gr.State(0.0)
+
+        # When registering the event listeners, we pass the `recording_id` in as input in order to create
+        # a recording stream using that id.
+        stream_blur.click(
+            # Using the `viewer` as an output allows us to stream data to it by yielding bytes from the callback.
+            streaming_repeated_blur,
+            inputs=[recording_id, img],
+            outputs=[viewer],
+        )
+        viewer.selection_change(
+            register_keypoint,
+            inputs=[recording_id, current_timeline, current_time],
+            outputs=[viewer],
+        )
+        viewer.time_update(track_current_time, outputs=[current_time])
+        viewer.timeline_change(
+            track_current_timeline_and_time, outputs=[current_timeline, current_time]
+        )
     with gr.Tab("Dynamic RRD"):
         pending_cleanup = gr.State(
             [], time_to_live=10, delete_callback=cleanup_cube_rrds
@@ -161,6 +285,8 @@ with gr.Blocks() as demo:
                 },
             )
         choose_rrd.change(lambda x: x, inputs=[choose_rrd], outputs=[viewer])
+    demo.load(initialize_instance)
+    demo.close(cleanup_instance)
 
 
 if __name__ == "__main__":

color_grid.py

@@ -1,11 +1,14 @@
-import numpy as np
+from collections import namedtuple  # noqa: D100
 from math import cos, sin
-from collections import namedtuple
+
+import numpy as np
 
 ColorGrid = namedtuple("ColorGrid", ["positions", "colors"])
 
 
-def build_color_grid(x_count=10, y_count=10, z_count=10, twist=0):
+def build_color_grid(
+    x_count: int = 10, y_count: int = 10, z_count: int = 10, twist: int = 0
+) -> ColorGrid:
     """
     Create a cube of points with colors.
 
@@ -19,7 +22,6 @@ def build_color_grid(x_count=10, y_count=10, z_count=10, twist=0):
         Angle to twist from bottom to top of the cube
 
     """
-
     grid = np.mgrid[
         slice(-x_count, x_count, x_count * 1j),
         slice(-y_count, y_count, y_count * 1j),

css.css

@@ -135,11 +135,11 @@ h6 {
 	letter-spacing: 0px !important;
 }
 
-#start .md > *:first-child {
+#start .md>*:first-child {
 	margin-top: 0;
 }
 
-h2 + h3 {
+h2+h3 {
 	margin-top: 0;
 }
 
@@ -148,10 +148,11 @@ h2 + h3 {
 	border-top: 1px solid var(--block-border-color);
 	margin: var(--vspace-2) 0 var(--vspace-2) 0;
 }
+
 .prose ul {
 	margin: var(--vspace-2) 0 var(--vspace-1) 0;
 }
 
 .gap {
 	gap: 0;
-}
+}

examples/rgbd.rrd

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:23a374ab6f973424d2e6d40d54c90a5898c4ae4c3909987167fc4e349e9f7b35
-size 38623309
+oid sha256:62a765f41f2779e7975290773ae2f24131eca986e9f7c9b829fbc0020900c422
+size 18464608

examples/rrt-star.rrd

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d26f9f5343552292208d232f2480ac24a7a9cebb331ba8ce4fa8ef3a44f5c283
-size 10487798
+oid sha256:5c7f1b7882df70a58e8544718941550a5dbf9252502b448e0a0318150b2d1442
+size 6173062

examples/structure_from_motion.rrd

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c6b4aae56c08714b4aa230cb2c75682eef8e2e6de1c2ea636e15e4eca0f9e26f
-size 7175301
+oid sha256:3a2c5f3808f43cc42d8f06587157ed87f555cb8ac363d65cc2fbe15521e21618
+size 6898468

requirements.txt

@@ -1,2 +1,2 @@
-gradio_rerun
+gradio_rerun>=0.23.0
 opencv-python

space.py

@@ -1,9 +1,134 @@
-
 import gradio as gr
 from app import demo as app
 import os
 
-_docs = {'Rerun': {'description': 'Creates a Rerun viewer component that can be used to display the output of a Rerun stream.', 'members': {'__init__': {'value': {'type': 'list[pathlib.Path | str]\n    | pathlib.Path\n    | str\n    | bytes\n    | Callable\n    | None', 'default': 'None', 'description': 'Takes a singular or list of RRD resources. Each RRD can be a Path, a string containing a url, or a binary blob containing encoded RRD data. If callable, the function will be called whenever the app loads to set the initial value of the component.'}, 'label': {'type': 'str | None', 'default': 'None', 'description': 'The label for this component. Appears above the component and is also used as the header if there are a table of examples for this component. If None and used in a `gr.Interface`, the label will be the name of the parameter this component is assigned to.'}, 'every': {'type': 'float | None', 'default': 'None', 'description': "If `value` is a callable, run the function 'every' number of seconds while the client connection is open. Has no effect otherwise. Queue must be enabled. The event can be accessed (e.g. to cancel it) via this component's .load_event attribute."}, 'show_label': {'type': 'bool | None', 'default': 'None', 'description': 'if True, will display label.'}, 'container': {'type': 'bool', 'default': 'True', 'description': 'If True, will place the component in a container - providing some extra padding around the border.'}, 'scale': {'type': 'int | None', 'default': 'None', 'description': 'relative size compared to adjacent Components. For example if Components A and B are in a Row, and A has scale=2, and B has scale=1, A will be twice as wide as B. Should be an integer. scale applies in Rows, and to top-level Components in Blocks where fill_height=True.'}, 'min_width': {'type': 'int', 'default': '160', 'description': 'minimum pixel width, will wrap if not sufficient screen space to satisfy this value. If a certain scale value results in this Component being narrower than min_width, the min_width parameter will be respected first.'}, 'height': {'type': 'int | str', 'default': '640', 'description': 'height of component in pixels. If a string is provided, will be interpreted as a CSS value. If None, will be set to 640px.'}, 'visible': {'type': 'bool', 'default': 'True', 'description': 'If False, component will be hidden.'}, 'streaming': {'type': 'bool', 'default': 'False', 'description': 'If True, the data should be incrementally yielded from the source as `bytes` returned by calling `.read()` on an `rr.binary_stream()`'}, 'elem_id': {'type': 'str | None', 'default': 'None', 'description': 'An optional string that is assigned as the id of this component in the HTML DOM. Can be used for targeting CSS styles.'}, 'elem_classes': {'type': 'list[str] | str | None', 'default': 'None', 'description': 'An optional list of strings that are assigned as the classes of this component in the HTML DOM. Can be used for targeting CSS styles.'}, 'render': {'type': 'bool', 'default': 'True', 'description': 'If False, component will not render be rendered in the Blocks context. Should be used if the intention is to assign event listeners now but render the component later.'}, 'panel_states': {'type': 'dict[str, Any] | None', 'default': 'None', 'description': 'Force viewer panels to a specific state. Any panels set cannot be toggled by the user in the viewer. Panel names are "top", "blueprint", "selection", and "time". States are "hidden", "collapsed", and "expanded".'}}, 'postprocess': {'value': {'type': 'list[pathlib.Path | str] | pathlib.Path | str | bytes', 'description': 'Expects'}}, 'preprocess': {'return': {'type': 'RerunData | None', 'description': 'A RerunData object.'}, 'value': None}}, 'events': {}}, '__meta__': {'additional_interfaces': {'RerunData': {'source': 'class RerunData(GradioRootModel):\n    root: list[FileData | str]'}}, 'user_fn_refs': {'Rerun': ['RerunData']}}}
+_docs = {
+    "Rerun": {
+        "description": "Creates a Rerun viewer component that can be used to display the output of a Rerun stream.",
+        "members": {
+            "__init__": {
+                "value": {
+                    "type": "list[pathlib.Path | str]\n    | pathlib.Path\n    | str\n    | bytes\n    | collections.abc.Callable\n    | None",
+                    "default": "None",
+                    "description": "Takes a singular or list of RRD resources. Each RRD can be a Path, a string containing a url,",
+                },
+                "label": {
+                    "type": "str | None",
+                    "default": "None",
+                    "description": "The label for this component. Appears above the component and is also used as the header if there",
+                },
+                "every": {
+                    "type": "float | None",
+                    "default": "None",
+                    "description": "If `value` is a callable, run the function 'every' number of seconds while the client connection is",
+                },
+                "show_label": {
+                    "type": "bool | None",
+                    "default": "None",
+                    "description": "if True, will display label.",
+                },
+                "container": {
+                    "type": "bool",
+                    "default": "True",
+                    "description": "If True, will place the component in a container providing some extra padding around the border.",
+                },
+                "scale": {
+                    "type": "int | None",
+                    "default": "None",
+                    "description": "relative size compared to adjacent Components.",
+                },
+                "min_width": {
+                    "type": "int",
+                    "default": "160",
+                    "description": "minimum pixel width, will wrap if not sufficient screen space to satisfy this value.",
+                },
+                "height": {
+                    "type": "int | str",
+                    "default": "640",
+                    "description": "height of component in pixels. If a string is provided, will be interpreted as a CSS value.",
+                },
+                "visible": {
+                    "type": "bool",
+                    "default": "True",
+                    "description": "If False, component will be hidden.",
+                },
+                "streaming": {
+                    "type": "bool",
+                    "default": "False",
+                    "description": "If True, the data should be incrementally yielded from the source as `bytes` returned by",
+                },
+                "elem_id": {
+                    "type": "str | None",
+                    "default": "None",
+                    "description": "An optional string that is assigned as the id of this component in the HTML DOM.",
+                },
+                "elem_classes": {
+                    "type": "list[str] | str | None",
+                    "default": "None",
+                    "description": "An optional list of strings that are assigned as the classes of this component in",
+                },
+                "render": {
+                    "type": "bool",
+                    "default": "True",
+                    "description": "If False, component will not render be rendered in the Blocks context.",
+                },
+                "panel_states": {
+                    "type": "dict[str, typing.Any] | None",
+                    "default": "None",
+                    "description": "Force viewer panels to a specific state.",
+                },
+            },
+            "postprocess": {
+                "value": {
+                    "type": "list[pathlib.Path | str] | pathlib.Path | str | bytes",
+                    "description": "The value to send over to the Rerun viewer on the front-end.",
+                }
+            },
+            "preprocess": {
+                "return": {
+                    "type": "RerunData | None",
+                    "description": "A `RerunData` object.",
+                },
+                "value": None,
+            },
+        },
+        "events": {
+            "play": {
+                "type": None,
+                "default": None,
+                "description": "Fired when timeline playback starts. Callback should accept a parameter of type `gradio_rerun.events.Play`",
+            },
+            "pause": {
+                "type": None,
+                "default": None,
+                "description": "Fired when timeline pauseback starts. Callback should accept a parameter of type `gradio_rerun.events.Pause`",
+            },
+            "time_update": {
+                "type": None,
+                "default": None,
+                "description": "Fired when time updates. Callback should accept a parameter of type `gradio_rerun.events.TimeUpdate`.",
+            },
+            "timeline_change": {
+                "type": None,
+                "default": None,
+                "description": "Fired when a timeline is selected. Callback should accept a parameter of type `gradio_rerun.events.TimelineChange`.",
+            },
+            "selection_change": {
+                "type": None,
+                "default": None,
+                "description": "Fired when the selection changes. Callback should accept a parameter of type `gradio_rerun.events.SelectionChange`.",
+            },
+        },
+    },
+    "__meta__": {
+        "additional_interfaces": {
+            "RerunData": {
+                "source": "class RerunData(GradioRootModel):\n    root: Sequence[FileData | Path | str] | None"
+            }
+        },
+        "user_fn_refs": {"Rerun": ["RerunData"]},
+    },
+}
 
 abs_path = os.path.join(os.path.dirname(__file__), "css.css")
 
@@ -17,18 +142,21 @@ with gr.Blocks(
     ),
 ) as demo:
     gr.Markdown(
-"""
+        """
 # `gradio_rerun`
 
 <div style="display: flex; gap: 7px;">
-<a href="https://pypi.org/project/gradio_rerun/" target="_blank"><img alt="PyPI - Version" src="https://img.shields.io/pypi/v/gradio_rerun"></a> <a href="https://github.com/radames/gradio-rerun-viewer/issues" target="_blank"><img alt="Static Badge" src="https://img.shields.io/badge/Issues-white?logo=github&logoColor=black"></a> 
+<a href="https://pypi.org/project/gradio_rerun/" target="_blank"><img alt="PyPI - Version" src="https://img.shields.io/pypi/v/gradio_rerun"></a> <a href="https://github.com/rerun-io/gradio-rerun-viewer/issues" target="_blank"><img alt="Static Badge" src="https://img.shields.io/badge/Issues-white?logo=github&logoColor=black"></a> <a href="https://huggingface.co/spaces/rerun/gradio-rerun-viewer/discussions" target="_blank"><img alt="Static Badge" src="https://img.shields.io/badge/%F0%9F%A4%97%20Discuss-%23097EFF?style=flat&logoColor=black"></a>
 </div>
 
 Rerun viewer with Gradio
-""", elem_classes=["md-custom"], header_links=True)
+""",
+        elem_classes=["md-custom"],
+        header_links=True,
+    )
     app.render()
     gr.Markdown(
-"""
+        """
 ## Installation
 
 ```bash
@@ -38,22 +166,37 @@ pip install gradio_rerun
 ## Usage
 
 ```python
-import cv2
+\"\"\"
+Demonstrates integrating Rerun visualization with Gradio.
+
+Provides example implementations of data streaming, keypoint annotation, and dynamic
+visualization across multiple Gradio tabs using Rerun's recording and visualization capabilities.
+\"\"\"
+
+import math
 import os
 import tempfile
 import time
+import uuid
 
+import cv2
 import gradio as gr
-from gradio_rerun import Rerun
-
 import rerun as rr
 import rerun.blueprint as rrb
-
 from color_grid import build_color_grid
+from gradio_rerun import Rerun
+from gradio_rerun.events import (
+    SelectionChange,
+    TimelineChange,
+    TimeUpdate,
+)
 
-# NOTE: Functions that work with Rerun should be decorated with `@rr.thread_local_stream`.
-# This decorator creates a generator-aware thread-local context so that rerun log calls
-# across multiple workers stay isolated.
+
+# Whenever we need a recording, we construct a new recording stream.
+# As long as the app and recording IDs remain the same, the data
+# will be merged by the Viewer.
+def get_recording(recording_id: str) -> rr.RecordingStream:
+    return rr.RecordingStream(application_id="rerun_example_gradio", recording_id=recording_id)
 
 
 # A task can directly log to a binary stream, which is routed to the embedded viewer.
@@ -61,9 +204,10 @@ from color_grid import build_color_grid
 #
 # This is the preferred way to work with Rerun in Gradio since your data can be immediately and
 # incrementally seen by the viewer. Also, there are no ephemeral RRDs to cleanup or manage.
-@rr.thread_local_stream("rerun_example_streaming_blur")
-def streaming_repeated_blur(img):
-    stream = rr.binary_stream()
+def streaming_repeated_blur(recording_id: str, img):
+    # Here we get a recording using the provided recording id.
+    rec = get_recording(recording_id)
+    stream = rec.binary_stream()
 
     if img is None:
         raise gr.Error("Must provide an image to blur.")
@@ -76,23 +220,19 @@ def streaming_repeated_blur(img):
         collapse_panels=True,
     )
 
-    rr.send_blueprint(blueprint)
-
-    rr.set_time_sequence("iteration", 0)
-
-    rr.log("image/original", rr.Image(img))
+    rec.send_blueprint(blueprint)
+    rec.set_time("iteration", sequence=0)
+    rec.log("image/original", rr.Image(img))
     yield stream.read()
 
     blur = img
-
     for i in range(100):
-        rr.set_time_sequence("iteration", i)
+        rec.set_time("iteration", sequence=i)
 
         # Pretend blurring takes a while so we can see streaming in action.
         time.sleep(0.1)
         blur = cv2.GaussianBlur(blur, (5, 5), 0)
-
-        rr.log("image/blurred", rr.Image(blur))
+        rec.log("image/blurred", rr.Image(blur))
 
         # Each time we yield bytes from the stream back to Gradio, they
         # are incrementally sent to the viewer. Make sure to yield any time
@@ -100,6 +240,87 @@ def streaming_repeated_blur(img):
         yield stream.read()
 
 
+# In this example the user is able to add keypoints to an image visualized in Rerun.
+# These keypoints are stored in the global state, we use the session id to keep track of which keypoints belong
+# to a specific session (https://www.gradio.app/guides/state-in-blocks).
+#
+# The current session can be obtained by adding a parameter of type `gradio.Request` to your event listener functions.
+Keypoint = tuple[float, float]
+keypoints_per_session_per_sequence_index: dict[str, dict[int, list[Keypoint]]] = {}
+
+
+def get_keypoints_for_user_at_sequence_index(request: gr.Request, sequence: int) -> list[Keypoint]:
+    per_sequence = keypoints_per_session_per_sequence_index[request.session_hash]
+    if sequence not in per_sequence:
+        per_sequence[sequence] = []
+
+    return per_sequence[sequence]
+
+
+def initialize_instance(request: gr.Request) -> None:
+    keypoints_per_session_per_sequence_index[request.session_hash] = {}
+
+
+def cleanup_instance(request: gr.Request) -> None:
+    if request.session_hash in keypoints_per_session_per_sequence_index:
+        del keypoints_per_session_per_sequence_index[request.session_hash]
+
+
+# In this function, the `request` and `evt` parameters will be automatically injected by Gradio when this
+# event listener is fired.
+#
+# `SelectionChange` is a subclass of `EventData`: https://www.gradio.app/docs/gradio/eventdata
+# `gr.Request`: https://www.gradio.app/main/docs/gradio/request
+def register_keypoint(
+    active_recording_id: str,
+    current_timeline: str,
+    current_time: float,
+    request: gr.Request,
+    change: SelectionChange,
+):
+    if active_recording_id == "":
+        return
+
+    if current_timeline != "iteration":
+        return
+
+    evt = change.payload
+
+    # We can only log a keypoint if the user selected only a single item.
+    if len(evt.items) != 1:
+        return
+    item = evt.items[0]
+
+    # If the selected item isn't an entity, or we don't have its position, then bail out.
+    if item.type != "entity" or item.position is None:
+        return
+
+    # Now we can produce a valid keypoint.
+    rec = get_recording(active_recording_id)
+    stream = rec.binary_stream()
+
+    # We round `current_time` toward 0, because that gives us the sequence index
+    # that the user is currently looking at, due to the Viewer's latest-at semantics.
+    index = math.floor(current_time)
+
+    # We keep track of the keypoints per sequence index for each user manually.
+    keypoints = get_keypoints_for_user_at_sequence_index(request, index)
+    keypoints.append(item.position[0:2])
+
+    rec.set_time("iteration", sequence=index)
+    rec.log(f"{item.entity_path}/keypoint", rr.Points2D(keypoints, radii=2))
+
+    yield stream.read()
+
+
+def track_current_time(evt: TimeUpdate):
+    return evt.payload.time
+
+
+def track_current_timeline_and_time(evt: TimelineChange):
+    return evt.payload.timeline, evt.payload.time
+
+
 # However, if you have a workflow that creates an RRD file instead, you can still send it
 # directly to the viewer by simply returning the path to the RRD file.
 #
@@ -107,12 +328,15 @@ def streaming_repeated_blur(img):
 # be easily modified to stream data directly via Gradio.
 #
 # In this case you may want to clean up the RRD file after it's sent to the viewer so that you
-# don't accumulate too many  temporary files.
+# don't accumulate too many temporary files.
 @rr.thread_local_stream("rerun_example_cube_rrd")
 def create_cube_rrd(x, y, z, pending_cleanup):
     cube = build_color_grid(int(x), int(y), int(z), twist=0)
     rr.log("cube", rr.Points3D(cube.positions, colors=cube.colors, radii=0.5))
 
+    # Simulate delay
+    time.sleep(x / 10)
+
     # We eventually want to clean up the RRD file after it's sent to the viewer, so tracking
     # any pending files to be cleaned up when the state is deleted.
     temp = tempfile.NamedTemporaryFile(prefix="cube_", suffix=".rrd", delete=False)
@@ -126,7 +350,7 @@ def create_cube_rrd(x, y, z, pending_cleanup):
     return temp.name
 
 
-def cleanup_cube_rrds(pending_cleanup):
+def cleanup_cube_rrds(pending_cleanup: list[str]) -> None:
     for f in pending_cleanup:
         os.unlink(f)
 
@@ -137,6 +361,7 @@ with gr.Blocks() as demo:
             img = gr.Image(interactive=True, label="Image")
             with gr.Column():
                 stream_blur = gr.Button("Stream Repeated Blur")
+
         with gr.Row():
             viewer = Rerun(
                 streaming=True,
@@ -146,22 +371,35 @@ with gr.Blocks() as demo:
                     "selection": "hidden",
                 },
             )
-        stream_blur.click(streaming_repeated_blur, inputs=[img], outputs=[viewer])
 
-    with gr.Tab("Dynamic RRD"):
-        pending_cleanup = gr.State(
-            [], time_to_live=10, delete_callback=cleanup_cube_rrds
+        # We make a new recording id, and store it in a Gradio's session state.
+        recording_id = gr.State(uuid.uuid4())
+
+        # Also store the current timeline and time of the viewer in the session state.
+        current_timeline = gr.State("")
+        current_time = gr.State(0.0)
+
+        # When registering the event listeners, we pass the `recording_id` in as input in order to create
+        # a recording stream using that id.
+        stream_blur.click(
+            # Using the `viewer` as an output allows us to stream data to it by yielding bytes from the callback.
+            streaming_repeated_blur,
+            inputs=[recording_id, img],
+            outputs=[viewer],
         )
+        viewer.selection_change(
+            register_keypoint,
+            inputs=[recording_id, current_timeline, current_time],
+            outputs=[viewer],
+        )
+        viewer.time_update(track_current_time, outputs=[current_time])
+        viewer.timeline_change(track_current_timeline_and_time, outputs=[current_timeline, current_time])
+    with gr.Tab("Dynamic RRD"):
+        pending_cleanup = gr.State([], time_to_live=10, delete_callback=cleanup_cube_rrds)
         with gr.Row():
-            x_count = gr.Number(
-                minimum=1, maximum=10, value=5, precision=0, label="X Count"
-            )
-            y_count = gr.Number(
-                minimum=1, maximum=10, value=5, precision=0, label="Y Count"
-            )
-            z_count = gr.Number(
-                minimum=1, maximum=10, value=5, precision=0, label="Z Count"
-            )
+            x_count = gr.Number(minimum=1, maximum=10, value=5, precision=0, label="X Count")
+            y_count = gr.Number(minimum=1, maximum=10, value=5, precision=0, label="Y Count")
+            z_count = gr.Number(minimum=1, maximum=10, value=5, precision=0, label="Z Count")
         with gr.Row():
             create_rrd = gr.Button("Create RRD")
         with gr.Row():
@@ -201,27 +439,36 @@ with gr.Blocks() as demo:
                 },
             )
         choose_rrd.change(lambda x: x, inputs=[choose_rrd], outputs=[viewer])
+    demo.load(initialize_instance)
+    demo.close(cleanup_instance)
 
 
 if __name__ == "__main__":
     demo.launch()
 
 ```
-""", elem_classes=["md-custom"], header_links=True)
-
+""",
+        elem_classes=["md-custom"],
+        header_links=True,
+    )
 
-    gr.Markdown("""
+    gr.Markdown(
+        """
 ## `Rerun`
 
 ### Initialization
-""", elem_classes=["md-custom"], header_links=True)
-
-    gr.ParamViewer(value=_docs["Rerun"]["members"]["__init__"], linkify=['RerunData'])
-
+""",
+        elem_classes=["md-custom"],
+        header_links=True,
+    )
 
+    gr.ParamViewer(value=_docs["Rerun"]["members"]["__init__"], linkify=["RerunData"])
 
+    gr.Markdown("### Events")
+    gr.ParamViewer(value=_docs["Rerun"]["events"], linkify=["Event"])
 
-    gr.Markdown("""
+    gr.Markdown(
+        """
 
 ### User function
 
@@ -232,8 +479,8 @@ The impact on the users predict function varies depending on whether the compone
 
 The code snippet below is accurate in cases where the component is used as both an input and an output.
 
-- **As input:** Is passed, a RerunData object.
-- **As output:** Should return, expects.
+- **As input:** Is passed, a `RerunData` object.
+- **As output:** Should return, the value to send over to the Rerun viewer on the front-end.
 
  ```python
 def predict(
@@ -241,19 +488,25 @@ def predict(
 ) -> list[pathlib.Path | str] | pathlib.Path | str | bytes:
     return value
 ```
-""", elem_classes=["md-custom", "Rerun-user-fn"], header_links=True)
-
-
-
+""",
+        elem_classes=["md-custom", "Rerun-user-fn"],
+        header_links=True,
+    )
 
-    code_RerunData = gr.Markdown("""
+    code_RerunData = gr.Markdown(
+        """
 ## `RerunData`
 ```python
 class RerunData(GradioRootModel):
-    root: list[FileData | str]
-```""", elem_classes=["md-custom", "RerunData"], header_links=True)
+    root: Sequence[FileData | Path | str] | None
+```""",
+        elem_classes=["md-custom", "RerunData"],
+        header_links=True,
+    )
 
-    demo.load(None, js=r"""function() {
+    demo.load(
+        None,
+        js=r"""function() {
     const refs = {
             RerunData: [], };
     const user_fn_refs = {
@@ -288,6 +541,7 @@ class RerunData(GradioRootModel):
     })
 }
 
-""")
+""",
+    )
 
 demo.launch()