Commit 2: Add 33 file(s)

demos/kitchen_sink_random/requirements.txt

@@ -0,0 +1,2 @@
+matplotlib
+pandas

demos/kitchen_sink_random/run.py

@@ -0,0 +1,104 @@
+import gradio as gr
+from datetime import datetime
+import random
+import string
+import pandas as pd
+
+# get_audio(), get_video(), get_image(), get_model3d(), get_file() return file paths to sample media included with Gradio
+from gradio.media import get_audio, get_video, get_image, get_model3d, get_file
+
+from constants import (  # type: ignore
+    highlighted_text,
+    highlighted_text_output_2,
+    highlighted_text_output_1,
+    random_plot,
+)
+
+demo = gr.Interface(
+    lambda *args: args[0],
+    inputs=[
+        gr.Textbox(value=lambda: datetime.now(), label="Current Time"),
+        gr.Number(value=lambda: random.random(), label="Ranom Percentage"),
+        gr.Slider(minimum=-1, maximum=1, randomize=True, label="Slider with randomize"),
+        gr.Slider(
+            minimum=0,
+            maximum=1,
+            value=lambda: random.random(),
+            label="Slider with value func",
+        ),
+        gr.Checkbox(value=lambda: random.random() > 0.5, label="Random Checkbox"),
+        gr.CheckboxGroup(
+            choices=["a", "b", "c", "d"],
+            value=lambda: random.choice(["a", "b", "c", "d"]),
+            label="Random CheckboxGroup",
+        ),
+        gr.Radio(
+            choices=list(string.ascii_lowercase),
+            value=lambda: random.choice(string.ascii_lowercase),
+        ),
+        gr.Dropdown(
+            choices=["a", "b", "c", "d", "e"],
+            value=lambda: random.choice(["a", "b", "c"]),
+        ),
+        gr.Image(
+            value=lambda: get_image()
+        ),
+        gr.Video(value=lambda: get_video("world.mp4")),
+        gr.Audio(value=lambda: get_audio("cantina.wav")),
+        gr.File(
+            value=lambda: get_file("titanic.csv")
+        ),
+        gr.Dataframe(
+            value=lambda: pd.DataFrame(
+                {"random_number_rows": range(random.randint(0, 10))}
+            )
+        ),
+        gr.State(value=lambda: random.choice(string.ascii_lowercase)),
+        gr.ColorPicker(value=lambda: random.choice(["#000000", "#ff0000", "#0000FF"])),
+        gr.Label(value=lambda: random.choice(["Pedestrian", "Car", "Cyclist"])),
+        gr.HighlightedText(
+            value=lambda: random.choice(
+                [
+                    {"text": highlighted_text, "entities": highlighted_text_output_1},
+                    {"text": highlighted_text, "entities": highlighted_text_output_2},
+                ]
+            ),
+        ),
+        gr.JSON(value=lambda: random.choice([{"a": 1}, {"b": 2}])),
+        gr.HTML(
+            value=lambda: random.choice(
+                [
+                    '<p style="color:red;">I am red</p>',
+                    '<p style="color:blue;">I am blue</p>',
+                ]
+            )
+        ),
+        gr.Gallery(
+            value=lambda: [get_image() for _ in range(3)]
+        ),
+        gr.Chatbot(
+            value=lambda: random.choice(
+                [
+                    [
+                        {"role": "user", "content": "hello"},
+                        {"role": "assistant", "content": "hi!"},
+                    ],
+                    [
+                        {"role": "user", "content": "bye"},
+                        {"role": "assistant", "content": "goodbye!"},
+                    ],
+                ]
+            )
+        ),
+        gr.Model3D(value=lambda: get_model3d()),
+        gr.Plot(value=random_plot),
+        gr.Markdown(value=lambda: f"### {random.choice(['Hello', 'Hi', 'Goodbye!'])}"),
+    ],
+    outputs=[
+        gr.State(value=lambda: random.choice(string.ascii_lowercase))
+    ],
+    api_name="predict",
+)
+
+if __name__ == "__main__":
+    demo.launch()

demos/login_with_huggingface/requirements.txt

@@ -0,0 +1 @@
+huggingface_hub

demos/login_with_huggingface/run.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+import gradio as gr
+from huggingface_hub import whoami
+
+def hello(profile: gr.OAuthProfile | None) -> str:
+    if profile is None:
+        return "I don't know you."
+    return f"Hello {profile.name}"
+
+def list_organizations(oauth_token: gr.OAuthToken | None) -> str:
+    if oauth_token is None:
+        return "Please deploy this on Spaces and log in to list organizations."
+    org_names = [org["name"] for org in whoami(oauth_token.token)["orgs"]]
+    return f"You belong to {', '.join(org_names)}."
+
+with gr.Blocks() as demo:
+    gr.LoginButton()
+    m1 = gr.Markdown()
+    m2 = gr.Markdown()
+    demo.load(hello, inputs=None, outputs=m1)
+    demo.load(list_organizations, inputs=None, outputs=m2)
+
+if __name__ == "__main__":
+    demo.launch()

demos/matrix_transpose/run.py

@@ -0,0 +1,24 @@
+import numpy as np
+
+import gradio as gr
+
+def transpose(matrix):
+    return matrix.T
+
+demo = gr.Interface(
+    transpose,
+    gr.Dataframe(type="numpy", datatype="number", row_count=5, column_count=3, buttons=["fullscreen"]),
+    "numpy",
+    examples=[
+        [np.zeros((30, 30)).tolist()],
+        [np.ones((2, 2)).tolist()],
+        [np.random.randint(0, 10, (3, 10)).tolist()],
+        [np.random.randint(0, 10, (10, 3)).tolist()],
+        [np.random.randint(0, 10, (10, 10)).tolist()],
+    ],
+    cache_examples=False,
+    api_name="predict"
+)
+
+if __name__ == "__main__":
+    demo.launch()

demos/mini_leaderboard/assets/custom_css.css

@@ -0,0 +1,87 @@
+/* Hides the final AutoEvalColumn */
+#llm-benchmark-tab-table table td:last-child,
+#llm-benchmark-tab-table table th:last-child {
+    display: none;
+}
+
+/* Limit the width of the first AutoEvalColumn so that names don't expand too much */
+table td:first-child,
+table th:first-child {
+    max-width: 400px;
+    overflow: auto;
+    white-space: nowrap;
+}
+
+/* Full width space */
+.gradio-container {
+  max-width: 95%!important;
+}
+
+/* Text style and margins */
+.markdown-text {
+    font-size: 16px !important;
+}
+
+#models-to-add-text {
+    font-size: 18px !important;
+}
+
+#citation-button span {
+    font-size: 16px !important;
+}
+
+#citation-button textarea {
+    font-size: 16px !important;
+}
+
+#citation-button > label > button {
+    margin: 6px;
+    transform: scale(1.3);
+}
+
+#search-bar-table-box > div:first-child {
+    background: none;
+    border: none;
+}
+ 
+#search-bar {
+    padding: 0px;
+}
+
+.tab-buttons button {
+    font-size: 20px;
+}
+
+/* Filters style */
+#filter_type{
+    border: 0;
+    padding-left: 0;
+    padding-top: 0;
+}
+#filter_type label {
+    display: flex;
+}
+#filter_type label > span{
+    margin-top: var(--spacing-lg);
+    margin-right: 0.5em;
+}
+#filter_type label > .wrap{
+    width: 103px;
+}
+#filter_type label > .wrap .wrap-inner{  
+    padding: 2px;
+}
+#filter_type label > .wrap .wrap-inner input{
+    width: 1px
+}
+#filter-columns-type{
+    border:0;
+    padding:0.5;
+}
+#filter-columns-size{
+    border:0;
+    padding:0.5;
+}
+#box-filter > .form{
+    border: 0
+}

demos/mini_leaderboard/requirements.txt

@@ -0,0 +1 @@
+pandas

demos/mini_leaderboard/run.py

@@ -0,0 +1,237 @@
+# type: ignore
+import gradio as gr
+import pandas as pd
+from pathlib import Path
+
+abs_path = Path(__file__).parent.absolute()
+
+df = pd.read_json(str(abs_path / "assets/leaderboard_data.json"))
+invisible_df = df.copy()
+
+COLS = [
+    "T",
+    "Model",
+    "Average ⬆️",
+    "ARC",
+    "HellaSwag",
+    "MMLU",
+    "TruthfulQA",
+    "Winogrande",
+    "GSM8K",
+    "Type",
+    "Architecture",
+    "Precision",
+    "Merged",
+    "Hub License",
+    "#Params (B)",
+    "Hub ❤️",
+    "Model sha",
+    "model_name_for_query",
+]
+ON_LOAD_COLS = [
+    "T",
+    "Model",
+    "Average ⬆️",
+    "ARC",
+    "HellaSwag",
+    "MMLU",
+    "TruthfulQA",
+    "Winogrande",
+    "GSM8K",
+    "model_name_for_query",
+]
+TYPES = [
+    "str",
+    "markdown",
+    "number",
+    "number",
+    "number",
+    "number",
+    "number",
+    "number",
+    "number",
+    "str",
+    "str",
+    "str",
+    "str",
+    "bool",
+    "str",
+    "number",
+    "number",
+    "bool",
+    "str",
+    "bool",
+    "bool",
+    "str",
+]
+NUMERIC_INTERVALS = {
+    "?": pd.Interval(-1, 0, closed="right"),
+    "~1.5": pd.Interval(0, 2, closed="right"),
+    "~3": pd.Interval(2, 4, closed="right"),
+    "~7": pd.Interval(4, 9, closed="right"),
+    "~13": pd.Interval(9, 20, closed="right"),
+    "~35": pd.Interval(20, 45, closed="right"),
+    "~60": pd.Interval(45, 70, closed="right"),
+    "70+": pd.Interval(70, 10000, closed="right"),
+}
+MODEL_TYPE = [str(s) for s in df["T"].unique()]
+Precision = [str(s) for s in df["Precision"].unique()]
+
+# Searching and filtering
+def update_table(
+    hidden_df: pd.DataFrame,
+    columns: list,
+    type_query: list,
+    precision_query: str,
+    size_query: list,
+    query: str,
+):
+    filtered_df = filter_models(hidden_df, type_query, size_query, precision_query)  # type: ignore
+    filtered_df = filter_queries(query, filtered_df)
+    df = select_columns(filtered_df, columns)
+    return df
+
+def search_table(df: pd.DataFrame, query: str) -> pd.DataFrame:
+    return df[(df["model_name_for_query"].str.contains(query, case=False))]  # type: ignore
+
+def select_columns(df: pd.DataFrame, columns: list) -> pd.DataFrame:
+    # We use COLS to maintain sorting
+    filtered_df = df[[c for c in COLS if c in df.columns and c in columns]]
+    return filtered_df  # type: ignore
+
+def filter_queries(query: str, filtered_df: pd.DataFrame) -> pd.DataFrame:
+    final_df = []
+    if query != "":
+        queries = [q.strip() for q in query.split(";")]
+        for _q in queries:
+            _q = _q.strip()
+            if _q != "":
+                temp_filtered_df = search_table(filtered_df, _q)
+                if len(temp_filtered_df) > 0:
+                    final_df.append(temp_filtered_df)
+        if len(final_df) > 0:
+            filtered_df = pd.concat(final_df)
+            filtered_df = filtered_df.drop_duplicates(  # type: ignore
+                subset=["Model", "Precision", "Model sha"]
+            )
+
+    return filtered_df
+
+def filter_models(
+    df: pd.DataFrame,
+    type_query: list,
+    size_query: list,
+    precision_query: list,
+) -> pd.DataFrame:
+    # Show all models
+    filtered_df = df
+
+    type_emoji = [t[0] for t in type_query]
+    filtered_df = filtered_df.loc[df["T"].isin(type_emoji)]
+    filtered_df = filtered_df.loc[df["Precision"].isin(precision_query + ["None"])]
+
+    numeric_interval = pd.IntervalIndex(
+        sorted([NUMERIC_INTERVALS[s] for s in size_query])  # type: ignore
+    )
+    params_column = pd.to_numeric(df["#Params (B)"], errors="coerce")
+    mask = params_column.apply(lambda x: any(numeric_interval.contains(x)))  # type: ignore
+    filtered_df = filtered_df.loc[mask]
+
+    return filtered_df
+
+demo = gr.Blocks()
+with demo:
+    gr.Markdown("""Test Space of the LLM Leaderboard""", elem_classes="markdown-text")
+
+    with gr.Tabs(elem_classes="tab-buttons") as tabs:
+        with gr.TabItem("🏅 LLM Benchmark", elem_id="llm-benchmark-tab-table", id=0):
+            with gr.Row():
+                with gr.Column():
+                    with gr.Row():
+                        search_bar = gr.Textbox(
+                            placeholder=" 🔍 Search for your model (separate multiple queries with `;`) and press ENTER...",
+                            show_label=False,
+                            elem_id="search-bar",
+                        )
+                    with gr.Row():
+                        shown_columns = gr.CheckboxGroup(
+                            choices=COLS,
+                            value=ON_LOAD_COLS,
+                            label="Select columns to show",
+                            elem_id="column-select",
+                            interactive=True,
+                        )
+                with gr.Column(min_width=320):
+                    filter_columns_type = gr.CheckboxGroup(
+                        label="Model types",
+                        choices=MODEL_TYPE,
+                        value=MODEL_TYPE,
+                        interactive=True,
+                        elem_id="filter-columns-type",
+                    )
+                    filter_columns_precision = gr.CheckboxGroup(
+                        label="Precision",
+                        choices=Precision,
+                        value=Precision,
+                        interactive=True,
+                        elem_id="filter-columns-precision",
+                    )
+                    filter_columns_size = gr.CheckboxGroup(
+                        label="Model sizes (in billions of parameters)",
+                        choices=list(NUMERIC_INTERVALS.keys()),
+                        value=list(NUMERIC_INTERVALS.keys()),
+                        interactive=True,
+                        elem_id="filter-columns-size",
+                    )
+
+            leaderboard_table = gr.components.Dataframe(
+                value=df[ON_LOAD_COLS],  # type: ignore
+                headers=ON_LOAD_COLS,
+                datatype=TYPES,
+                elem_id="leaderboard-table",
+                interactive=False,
+                visible=True,
+                column_widths=["2%", "33%"],
+            )
+
+            # Dummy leaderboard for handling the case when the user uses backspace key
+            hidden_leaderboard_table_for_search = gr.components.Dataframe(
+                value=invisible_df[COLS],  # type: ignore
+                headers=COLS,
+                datatype=TYPES,
+                visible=False,
+            )
+            search_bar.submit(
+                update_table,
+                [
+                    hidden_leaderboard_table_for_search,
+                    shown_columns,
+                    filter_columns_type,
+                    filter_columns_precision,
+                    filter_columns_size,
+                    search_bar,
+                ],
+                leaderboard_table,
+            )
+            for selector in [
+                shown_columns,
+                filter_columns_type,
+                filter_columns_precision,
+                filter_columns_size,
+            ]:
+                selector.change(
+                    update_table,
+                    [
+                        hidden_leaderboard_table_for_search,
+                        shown_columns,
+                        filter_columns_type,
+                        filter_columns_precision,
+                        filter_columns_size,
+                        search_bar,
+                    ],
+                    leaderboard_table,
+                    queue=True,
+                )
+
+if __name__ == "__main__":
+    demo.queue(default_concurrency_limit=40).launch(css=str(abs_path / "assets/custom_css.css"))

demos/model3D/run.py

@@ -0,0 +1,34 @@
+import gradio as gr
+# get_model3d() returns the file path to sample 3D models included with Gradio
+from gradio.media import get_model3d, MEDIA_ROOT
+
+
+def load_mesh(mesh_file_name):
+    return mesh_file_name
+
+
+demo = gr.Interface(
+    fn=load_mesh,
+    inputs=gr.Model3D(label="Other name", display_mode="wireframe"),
+    outputs=gr.Model3D(
+        clear_color=(0.0, 0.0, 0.0, 0.0), label="3D Model", display_mode="wireframe"
+    ),
+    examples=[
+        [get_model3d("Bunny.obj")],
+        [get_model3d("Duck.glb")],
+        [get_model3d("Fox.gltf")],
+        [get_model3d("face.obj")],
+        [get_model3d("sofia.stl")],
+        [
+            "https://huggingface.co/datasets/dylanebert/3dgs/resolve/main/bonsai/bonsai-7k-mini.splat"
+        ],
+        [
+            "https://huggingface.co/datasets/dylanebert/3dgs/resolve/main/luigi/luigi.ply"
+        ],
+    ],
+    cache_examples=True,
+    api_name="predict",
+)
+
+if __name__ == "__main__":
+    demo.launch(allowed_paths=[str(MEDIA_ROOT)])

demos/native_plots/bar_plot_demo.py

@@ -0,0 +1,80 @@
+import gradio as gr
+from data import temp_sensor_data, food_rating_data  # type: ignore
+
+with gr.Blocks() as bar_plots:
+    with gr.Row():
+        start = gr.DateTime("2021-01-01 00:00:00", label="Start")
+        end = gr.DateTime("2021-01-05 00:00:00", label="End")
+        apply_btn = gr.Button("Apply", scale=0)
+    with gr.Row():
+        group_by = gr.Radio(["None", "30m", "1h", "4h", "1d"], value="None", label="Group by")
+        aggregate = gr.Radio(["sum", "mean", "median", "min", "max"], value="sum", label="Aggregation")
+
+    with gr.Draggable():
+        temp_by_time = gr.BarPlot(
+            temp_sensor_data,
+            x="time",
+            y="temperature",
+            buttons=["export"],
+        )
+        temp_by_time_location = gr.BarPlot(
+            temp_sensor_data,
+            x="time",
+            y="temperature",
+            color="location",
+            buttons=["export"],
+        )
+
+    time_graphs = [temp_by_time, temp_by_time_location]
+    group_by.change(
+        lambda group: [gr.BarPlot(x_bin=None if group == "None" else group)] * len(time_graphs),
+        group_by,
+        time_graphs
+    )
+    aggregate.change(
+        lambda aggregate: [gr.BarPlot(y_aggregate=aggregate)] * len(time_graphs),
+        aggregate,
+        time_graphs
+    )
+
+    def rescale(select: gr.SelectData):
+        return select.index
+    rescale_evt = gr.on([plot.select for plot in time_graphs], rescale, None, [start, end])
+
+    for trigger in [apply_btn.click, rescale_evt.then]:
+        trigger(
+            lambda start, end: [gr.BarPlot(x_lim=[start, end])] * len(time_graphs), [start, end], time_graphs
+        )
+
+    with gr.Row():
+        price_by_cuisine = gr.BarPlot(
+            food_rating_data,
+            x="cuisine",
+            y="price",
+            buttons=["export"],
+        )
+        with gr.Column(scale=0):
+            gr.Button("Sort $ > $$$").click(lambda: gr.BarPlot(sort="y"), None, price_by_cuisine)
+            gr.Button("Sort $$$ > $").click(lambda: gr.BarPlot(sort="-y"), None, price_by_cuisine)
+            gr.Button("Sort A > Z").click(lambda: gr.BarPlot(sort=["Chinese", "Italian", "Mexican"]), None, price_by_cuisine)
+
+    with gr.Row():
+        price_by_rating = gr.BarPlot(
+            food_rating_data,
+            x="rating",
+            y="price",
+            x_bin=1,
+            buttons=["export"],
+        )
+        price_by_rating_color = gr.BarPlot(
+            food_rating_data,
+            x="rating",
+            y="price",
+            color="cuisine",
+            x_bin=1,
+            color_map={"Italian": "red", "Mexican": "green", "Chinese": "blue"},
+            buttons=["export"],
+        )
+
+if __name__ == "__main__":
+    bar_plots.launch()

demos/native_plots/data.py

@@ -0,0 +1,20 @@
+import pandas as pd
+from random import randint, random
+
+temp_sensor_data = pd.DataFrame(
+    {
+        "time": pd.date_range("2021-01-01", end="2021-01-05", periods=200),
+        "temperature": [randint(50 + 10 * (i % 2), 65 + 15 * (i % 2)) for i in range(200)],
+        "humidity": [randint(50 + 10 * (i % 2), 65 + 15 * (i % 2)) for i in range(200)],
+        "location": ["indoor", "outdoor"] * 100,
+    }
+)
+
+food_rating_data = pd.DataFrame(
+    {
+        "cuisine": [["Italian", "Mexican", "Chinese"][i % 3] for i in range(100)],
+        "rating": [random() * 4 + 0.5 * (i % 3) for i in range(100)],
+        "price": [randint(10, 50) + 4 * (i % 3) for i in range(100)],
+        "wait": [random() for i in range(100)],
+    }
+)

demos/native_plots/line_plot_demo.py

@@ -0,0 +1,75 @@
+import gradio as gr
+from data import temp_sensor_data, food_rating_data  # type: ignore
+
+with gr.Blocks() as line_plots:
+    with gr.Row():
+        start = gr.DateTime("2021-01-01 00:00:00", label="Start")
+        end = gr.DateTime("2021-01-05 00:00:00", label="End")
+        apply_btn = gr.Button("Apply", scale=0)
+    with gr.Row():
+        group_by = gr.Radio(["None", "30m", "1h", "4h", "1d"], value="None", label="Group by")
+        aggregate = gr.Radio(["sum", "mean", "median", "min", "max"], value="sum", label="Aggregation")
+
+    temp_by_time = gr.LinePlot(
+        temp_sensor_data,
+        x="time",
+        y="temperature",
+        buttons=["export"],
+    )
+    temp_by_time_location = gr.LinePlot(
+        temp_sensor_data,
+        x="time",
+        y="temperature",
+        color="location",
+        buttons=["export"],
+    )
+
+    time_graphs = [temp_by_time, temp_by_time_location]
+    group_by.change(
+        lambda group: [gr.LinePlot(x_bin=None if group == "None" else group)] * len(time_graphs),
+        group_by,
+        time_graphs
+    )
+    aggregate.change(
+        lambda aggregate: [gr.LinePlot(y_aggregate=aggregate)] * len(time_graphs),
+        aggregate,
+        time_graphs
+    )
+
+    def rescale(select: gr.SelectData):
+        return select.index
+    rescale_evt = gr.on([plot.select for plot in time_graphs], rescale, None, [start, end])
+
+    for trigger in [apply_btn.click, rescale_evt.then]:
+        trigger(
+            lambda start, end: [gr.LinePlot(x_lim=[start, end])] * len(time_graphs), [start, end], time_graphs
+        )
+
+    price_by_cuisine = gr.LinePlot(
+        food_rating_data,
+        x="cuisine",
+        y="price",
+        buttons=["export"],
+    )
+    with gr.Row():
+        price_by_rating = gr.LinePlot(
+            food_rating_data,
+            title="Price by Rating (for Ratings >2)",
+            x="rating",
+            y="price",
+            x_lim=[2, None],
+            buttons=["export"],
+        )
+        price_by_rating_color = gr.LinePlot(
+            food_rating_data,
+            title="Price by Rating (for Ratings <4)",
+            x="rating",
+            y="price",
+            x_lim=[None, 4],
+            color="cuisine",
+            color_map={"Italian": "red", "Mexican": "green", "Chinese": "blue"},
+            buttons=["export"],
+        )
+
+if __name__ == "__main__":
+    line_plots.launch()

demos/native_plots/requirements.txt

@@ -0,0 +1,2 @@
+vega_datasets
+pandas

demos/native_plots/run.py

@@ -0,0 +1,17 @@
+import gradio as gr
+
+from scatter_plot_demo import scatter_plots  # type: ignore
+from line_plot_demo import line_plots  # type: ignore
+from bar_plot_demo import bar_plots  # type: ignore
+
+with gr.Blocks() as demo:
+    with gr.Tabs():
+        with gr.TabItem("Line Plot"):
+            line_plots.render()
+        with gr.TabItem("Scatter Plot"):
+            scatter_plots.render()
+        with gr.TabItem("Bar Plot"):
+            bar_plots.render()
+
+if __name__ == "__main__":
+    demo.launch()

demos/native_plots/scatter_plot_demo.py

@@ -0,0 +1,71 @@
+import gradio as gr
+from data import temp_sensor_data, food_rating_data  # type: ignore
+
+with gr.Blocks() as scatter_plots:
+    with gr.Row():
+        start = gr.DateTime("2021-01-01 00:00:00", label="Start")
+        end = gr.DateTime("2021-01-05 00:00:00", label="End")
+        apply_btn = gr.Button("Apply", scale=0)
+    with gr.Row():
+        group_by = gr.Radio(["None", "30m", "1h", "4h", "1d"], value="None", label="Group by")
+        aggregate = gr.Radio(["sum", "mean", "median", "min", "max"], value="sum", label="Aggregation")
+
+    temp_by_time = gr.ScatterPlot(
+        temp_sensor_data,
+        x="time",
+        y="temperature",
+        buttons=["export"],
+    )
+    temp_by_time_location = gr.ScatterPlot(
+        temp_sensor_data,
+        x="time",
+        y="temperature",
+        color="location",
+        buttons=["export"],
+    )
+
+    time_graphs = [temp_by_time, temp_by_time_location]
+    group_by.change(
+        lambda group: [gr.ScatterPlot(x_bin=None if group == "None" else group)] * len(time_graphs),
+        group_by,
+        time_graphs
+    )
+    aggregate.change(
+        lambda aggregate: [gr.ScatterPlot(y_aggregate=aggregate)] * len(time_graphs),
+        aggregate,
+        time_graphs
+    )
+
+    # def rescale(select: gr.SelectData):
+    #     return select.index
+    # rescale_evt = gr.on([plot.select for plot in time_graphs], rescale, None, [start, end])
+
+    # for trigger in [apply_btn.click, rescale_evt.then]:
+    #     trigger(
+    #         lambda start, end: [gr.ScatterPlot(x_lim=[start, end])] * len(time_graphs), [start, end], time_graphs
+    #     )
+
+    price_by_cuisine = gr.ScatterPlot(
+        food_rating_data,
+        x="cuisine",
+        y="price",
+        buttons=["export"],
+    )
+    with gr.Row():
+        price_by_rating = gr.ScatterPlot(
+            food_rating_data,
+            x="rating",
+            y="price",
+            color="wait",
+            buttons=["actions", "export"],  # type: ignore
+        )
+        price_by_rating_color = gr.ScatterPlot(
+            food_rating_data,
+            x="rating",
+            y="price",
+            color="cuisine",
+            buttons=["export"],
+        )
+
+if __name__ == "__main__":
+    scatter_plots.launch()

demos/reverse_audio/requirements.txt

@@ -0,0 +1 @@
+numpy

demos/reverse_audio/run.py

@@ -0,0 +1,27 @@
+
+import numpy as np
+
+import gradio as gr
+
+def reverse_audio(audio):
+    sr, data = audio
+    return (sr, np.flipud(data))
+
+input_audio = gr.Audio(
+    sources=["microphone"],
+    waveform_options=gr.WaveformOptions(
+        waveform_color="#01C6FF",
+        waveform_progress_color="#0066B4",
+        skip_length=2,
+        show_recording_waveform=False,
+    ),
+)
+demo = gr.Interface(
+    fn=reverse_audio,
+    inputs=input_audio,
+    outputs="audio",
+    api_name="predict",
+)
+
+if __name__ == "__main__":
+    demo.launch()

demos/stream_audio/requirements.txt

@@ -0,0 +1 @@
+numpy

demos/stream_audio/run.py

@@ -0,0 +1,23 @@
+import gradio as gr
+import numpy as np
+
+def add_to_stream(audio, instream):
+    if audio is None:
+        return gr.Audio(), instream
+    if instream is None:
+        ret = audio
+    else:
+        ret = (audio[0], np.concatenate((instream[1], audio[1])))
+    return ret, ret
+
+with gr.Blocks() as demo:
+    inp = gr.Audio(sources=["microphone"])
+    out = gr.Audio()
+    stream = gr.State()
+    clear = gr.Button("Clear")
+
+    inp.stream(add_to_stream, [inp, stream], [out, stream])
+    clear.click(lambda: [None, None, None], None, [inp, out, stream])
+
+if __name__ == "__main__":
+    demo.launch()

demos/stream_audio_out/run.py

@@ -0,0 +1,60 @@
+import gradio as gr
+from pydub import AudioSegment
+from time import sleep
+import os
+import tempfile
+from pathlib import Path
+
+with gr.Blocks() as demo:
+    input_audio = gr.Audio(label="Input Audio", type="filepath", format="mp3")
+    with gr.Row():
+        with gr.Column():
+            stream_as_file_btn = gr.Button("Stream as File")
+            format = gr.Radio(["wav", "mp3"], value="wav", label="Format")
+            stream_as_file_output = gr.Audio(streaming=True, elem_id="stream_as_file_output", autoplay=True, visible=False)
+
+            def stream_file(audio_file, format):
+                audio = AudioSegment.from_file(audio_file)
+                i = 0
+                chunk_size = 1000
+                while chunk_size * i < len(audio):
+                    chunk = audio[chunk_size * i : chunk_size * (i + 1)]
+                    i += 1
+                    if chunk:
+                        file = Path(tempfile.gettempdir()) / "stream_audio_demo" / f"{i}.{format}"
+                        file.parent.mkdir(parents=True, exist_ok=True)
+                        chunk.export(str(file), format=format)
+                        yield file
+                        sleep(0.5)
+
+            stream_as_file_btn.click(
+                stream_file, [input_audio, format], stream_as_file_output
+            )
+
+            gr.Examples(
+                [[gr.get_audio("cantina.wav"), "wav"],
+                 [gr.get_audio("cantina.wav"), "mp3"]],
+                [input_audio, format],
+                fn=stream_file,
+                outputs=stream_as_file_output,
+                cache_examples=False,
+            )
+
+        with gr.Column():
+            stream_as_bytes_btn = gr.Button("Stream as Bytes")
+            stream_as_bytes_output = gr.Audio(streaming=True, elem_id="stream_as_bytes_output", autoplay=True)
+
+            def stream_bytes(audio_file):
+                chunk_size = 20_000
+                with open(audio_file, "rb") as f:
+                    while True:
+                        chunk = f.read(chunk_size)
+                        if chunk:
+                            yield chunk
+                            sleep(1)
+                        else:
+                            break
+            stream_as_bytes_btn.click(stream_bytes, input_audio, stream_as_bytes_output)
+
+if __name__ == "__main__":
+    demo.launch()

demos/stream_frames/requirements.txt

@@ -0,0 +1 @@
+numpy

demos/stream_frames/run.py

@@ -0,0 +1,15 @@
+import gradio as gr
+import numpy as np
+
+def flip(im):
+    return np.flipud(im)
+
+demo = gr.Interface(
+    flip,
+    gr.Image(sources=["webcam"], streaming=True),
+    "image",
+    live=True,
+    api_name="predict",
+)
+if __name__ == "__main__":
+    demo.launch()

demos/stt_or_tts/run.py

@@ -0,0 +1,27 @@
+import gradio as gr
+
+tts_examples = [
+    "I love learning machine learning",
+    "How do you do?",
+]
+
+tts_demo = gr.load(
+    "huggingface/facebook/fastspeech2-en-ljspeech",
+    title=None,
+    examples=tts_examples,
+    description="Give me something to say!",
+    cache_examples=False
+)
+
+stt_demo = gr.load(
+    "huggingface/facebook/wav2vec2-base-960h",
+    title=None,
+    inputs=gr.Microphone(type="filepath"),
+    description="Let me try to guess what you're saying!",
+    cache_examples=False
+)
+
+demo = gr.TabbedInterface([tts_demo, stt_demo], ["Text-to-speech", "Speech-to-text"])
+
+if __name__ == "__main__":
+    demo.launch()

demos/video_component/run.py

@@ -0,0 +1,19 @@
+import gradio as gr
+# get_video() returns the file path to sample videos included with Gradio
+from gradio.media import get_video, MEDIA_PATHS
+
+demo = gr.Interface(
+    fn=lambda x: x,
+    inputs=gr.Video(),
+    outputs=gr.Video(),
+    examples=[
+        [get_video("world.mp4")],
+        [get_video("a.mp4")],
+        [get_video("b.mp4")],
+    ],
+    api_name="predict",
+    cache_examples=True
+)
+
+if __name__ == "__main__":
+    demo.launch(allowed_paths=[str(p) for p in MEDIA_PATHS])

demos/zip_files/run.py

@@ -0,0 +1,23 @@
+from zipfile import ZipFile
+
+import gradio as gr
+
+def zip_files(files):
+    with ZipFile("tmp.zip", "w") as zip_obj:
+        for file in files:
+            zip_obj.write(file.name, file.name.split("/")[-1])
+    return "tmp.zip"
+
+demo = gr.Interface(
+    zip_files,
+    gr.File(file_count="multiple", file_types=["text", ".json", ".csv"]),
+    "file",
+    examples=[[[gr.get_file("titanic.csv"),
+    gr.get_file("titanic.csv"),
+    gr.get_file("titanic.csv")]]],
+    cache_examples=True,
+    api_name="predict"
+)
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,7 @@
+gradio-client @ git+https://github.com/gradio-app/gradio@a3716939b6cdcab788a7a295bfa2abaaa87e2196#subdirectory=client/python
+https://huggingface.co/buckets/gradio/pypi-previews/resolve/a3716939b6cdcab788a7a295bfa2abaaa87e2196/gradio-6.26.0-py3-none-any.whl
+pypistats==1.1.0
+plotly
+matplotlib
+altair
+vega_datasets

run.py

@@ -0,0 +1,46 @@
+import importlib
+import gradio as gr
+import os
+import sys
+import copy
+import pathlib
+from gradio.media import MEDIA_ROOT
+
+os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
+
+demo_dir = pathlib.Path(__file__).parent / "demos"
+
+names = sorted(os.listdir("./demos"))
+
+all_demos = []
+demo_module = None
+for p in sorted(os.listdir("./demos")):
+    old_path = copy.deepcopy(sys.path)
+    sys.path = [os.path.join(demo_dir, p)] + sys.path
+    try:  # Some demos may not be runnable because of 429 timeouts, etc.
+        if demo_module is None:
+            demo_module = importlib.import_module("run")
+        else:
+            demo_module = importlib.reload(demo_module)
+        all_demos.append((p, demo_module.demo, False))  # type: ignore
+    except Exception as e:
+        with gr.Blocks() as demo:
+            gr.Markdown(f"Error loading demo: {e}")
+        all_demos.append((p, demo, True))
+
+app = gr.Blocks()
+
+with app:
+    gr.Markdown("""
+# Deployed Demos
+## Click through demos to test them out!
+""")
+
+for demo_name, demo, _ in all_demos:
+    with app.route(demo_name):
+        demo.render()
+
+    # app = gr.mount_gradio_app(app, demo, f"/demo/{demo_name}")
+
+if __name__ == "__main__":
+    app.launch(allowed_paths=[str(MEDIA_ROOT)])