Commit 2: Add 50 file(s)

demos/image_segmentation/requirements.txt

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

demos/image_segmentation/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": "302934307671667531413257853548643485645", "metadata": {}, "source": ["# Gradio Demo: image_segmentation\n", "### Simple image segmentation using gradio's AnnotatedImage component.\n", "        "]}, {"cell_type": "code", "execution_count": null, "id": "272996653310673477252411125948039410165", "metadata": {}, "outputs": [], "source": ["!pip install -q gradio numpy "]}, {"cell_type": "code", "execution_count": null, "id": "288918539441861185822528903084949547379", "metadata": {}, "outputs": [], "source": ["import gradio as gr\n", "import numpy as np\n", "import random\n", "\n", "with gr.Blocks() as demo:\n", "    section_labels = [\n", "        \"apple\",\n", "        \"banana\",\n", "        \"carrot\",\n", "        \"donut\",\n", "        \"eggplant\",\n", "        \"fish\",\n", "        \"grapes\",\n", "        \"hamburger\",\n", "        \"ice cream\",\n", "        \"juice\",\n", "    ]\n", "\n", "    with gr.Row():\n", "        num_boxes = gr.Slider(0, 5, 2, step=1, label=\"Number of boxes\")\n", "        num_segments = gr.Slider(0, 5, 1, step=1, label=\"Number of segments\")\n", "\n", "    with gr.Row():\n", "        img_input = gr.Image()\n", "        img_output = gr.AnnotatedImage(\n", "            color_map={\"banana\": \"#a89a00\", \"carrot\": \"#ffae00\"}\n", "        )\n", "\n", "    section_btn = gr.Button(\"Identify Sections\")\n", "    selected_section = gr.Textbox(label=\"Selected Section\")\n", "\n", "    def section(img, num_boxes, num_segments):\n", "        sections = []\n", "        for a in range(num_boxes):\n", "            x = random.randint(0, img.shape[1])\n", "            y = random.randint(0, img.shape[0])\n", "            w = random.randint(0, img.shape[1] - x)\n", "            h = random.randint(0, img.shape[0] - y)\n", "            sections.append(((x, y, x + w, y + h), section_labels[a]))\n", "        for b in range(num_segments):\n", "            x = random.randint(0, img.shape[1])\n", "            y = random.randint(0, img.shape[0])\n", "            r = random.randint(0, min(x, y, img.shape[1] - x, img.shape[0] - y))\n", "            mask = np.zeros(img.shape[:2])\n", "            for i in range(img.shape[0]):\n", "                for j in range(img.shape[1]):\n", "                    dist_square = (i - y) ** 2 + (j - x) ** 2\n", "                    if dist_square < r**2:\n", "                        mask[i, j] = round((r**2 - dist_square) / r**2 * 4) / 4\n", "            sections.append((mask, section_labels[b + num_boxes]))\n", "        return (img, sections)\n", "\n", "    section_btn.click(section, [img_input, num_boxes, num_segments], img_output)\n", "\n", "    def select_section(evt: gr.SelectData):\n", "        return section_labels[evt.index]\n", "\n", "    img_output.select(select_section, None, selected_section)\n", "\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

demos/image_segmentation/run.py

@@ -0,0 +1,61 @@
+import gradio as gr
+import numpy as np
+import random
+
+with gr.Blocks() as demo:
+    section_labels = [
+        "apple",
+        "banana",
+        "carrot",
+        "donut",
+        "eggplant",
+        "fish",
+        "grapes",
+        "hamburger",
+        "ice cream",
+        "juice",
+    ]
+
+    with gr.Row():
+        num_boxes = gr.Slider(0, 5, 2, step=1, label="Number of boxes")
+        num_segments = gr.Slider(0, 5, 1, step=1, label="Number of segments")
+
+    with gr.Row():
+        img_input = gr.Image()
+        img_output = gr.AnnotatedImage(
+            color_map={"banana": "#a89a00", "carrot": "#ffae00"}
+        )
+
+    section_btn = gr.Button("Identify Sections")
+    selected_section = gr.Textbox(label="Selected Section")
+
+    def section(img, num_boxes, num_segments):
+        sections = []
+        for a in range(num_boxes):
+            x = random.randint(0, img.shape[1])
+            y = random.randint(0, img.shape[0])
+            w = random.randint(0, img.shape[1] - x)
+            h = random.randint(0, img.shape[0] - y)
+            sections.append(((x, y, x + w, y + h), section_labels[a]))
+        for b in range(num_segments):
+            x = random.randint(0, img.shape[1])
+            y = random.randint(0, img.shape[0])
+            r = random.randint(0, min(x, y, img.shape[1] - x, img.shape[0] - y))
+            mask = np.zeros(img.shape[:2])
+            for i in range(img.shape[0]):
+                for j in range(img.shape[1]):
+                    dist_square = (i - y) ** 2 + (j - x) ** 2
+                    if dist_square < r**2:
+                        mask[i, j] = round((r**2 - dist_square) / r**2 * 4) / 4
+            sections.append((mask, section_labels[b + num_boxes]))
+        return (img, sections)
+
+    section_btn.click(section, [img_input, num_boxes, num_segments], img_output)
+
+    def select_section(evt: gr.SelectData):
+        return section_labels[evt.index]
+
+    img_output.select(select_section, None, selected_section)
+
+if __name__ == "__main__":
+    demo.launch()

demos/interface_random_slider/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": "302934307671667531413257853548643485645", "metadata": {}, "source": ["# Gradio Demo: interface_random_slider"]}, {"cell_type": "code", "execution_count": null, "id": "272996653310673477252411125948039410165", "metadata": {}, "outputs": [], "source": ["!pip install -q gradio "]}, {"cell_type": "code", "execution_count": null, "id": "288918539441861185822528903084949547379", "metadata": {}, "outputs": [], "source": ["import gradio as gr\n", "\n", "def func(slider_1, slider_2, *args):\n", "    return slider_1 + slider_2 * 5\n", "\n", "demo = gr.Interface(\n", "    func,\n", "    [\n", "        gr.Slider(minimum=1.5, maximum=250000.89, randomize=True, label=\"Random Big Range\"),\n", "        gr.Slider(minimum=-1, maximum=1, randomize=True, step=0.05, label=\"Random only multiple of 0.05 allowed\"),\n", "        gr.Slider(minimum=0, maximum=1, randomize=True, step=0.25, label=\"Random only multiples of 0.25 allowed\"),\n", "        gr.Slider(minimum=-100, maximum=100, randomize=True, step=3, label=\"Random between -100 and 100 step 3\"),\n", "        gr.Slider(minimum=-100, maximum=100, randomize=True, label=\"Random between -100 and 100\"),\n", "        gr.Slider(value=0.25, minimum=5, maximum=30, step=-1),\n", "    ],\n", "    \"number\",\n", ")\n", "\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

demos/interface_random_slider/run.py

@@ -0,0 +1,20 @@
+import gradio as gr
+
+def func(slider_1, slider_2, *args):
+    return slider_1 + slider_2 * 5
+
+demo = gr.Interface(
+    func,
+    [
+        gr.Slider(minimum=1.5, maximum=250000.89, randomize=True, label="Random Big Range"),
+        gr.Slider(minimum=-1, maximum=1, randomize=True, step=0.05, label="Random only multiple of 0.05 allowed"),
+        gr.Slider(minimum=0, maximum=1, randomize=True, step=0.25, label="Random only multiples of 0.25 allowed"),
+        gr.Slider(minimum=-100, maximum=100, randomize=True, step=3, label="Random between -100 and 100 step 3"),
+        gr.Slider(minimum=-100, maximum=100, randomize=True, label="Random between -100 and 100"),
+        gr.Slider(value=0.25, minimum=5, maximum=30, step=-1),
+    ],
+    "number",
+)
+
+if __name__ == "__main__":
+    demo.launch()

demos/kitchen_sink/requirements.txt

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

demos/kitchen_sink/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": "302934307671667531413257853548643485645", "metadata": {}, "source": ["# Gradio Demo: kitchen_sink"]}, {"cell_type": "code", "execution_count": null, "id": "272996653310673477252411125948039410165", "metadata": {}, "outputs": [], "source": ["!pip install -q gradio numpy "]}, {"cell_type": "code", "execution_count": null, "id": "288918539441861185822528903084949547379", "metadata": {}, "outputs": [], "source": ["import os\n", "import json\n", "\n", "import numpy as np\n", "\n", "import gradio as gr\n", "from gradio.media import get_image, get_video, get_audio, get_file\n", "\n", "CHOICES = [\"foo\", \"bar\", \"baz\"]\n", "JSONOBJ = \"\"\"{\"items\":{\"item\":[{\"id\": \"0001\",\"type\": null,\"is_good\": false,\"ppu\": 0.55,\"batters\":{\"batter\":[{ \"id\": \"1001\", \"type\": \"Regular\" },{ \"id\": \"1002\", \"type\": \"Chocolate\" },{ \"id\": \"1003\", \"type\": \"Blueberry\" },{ \"id\": \"1004\", \"type\": \"Devil's Food\" }]},\"topping\":[{ \"id\": \"5001\", \"type\": \"None\" },{ \"id\": \"5002\", \"type\": \"Glazed\" },{ \"id\": \"5005\", \"type\": \"Sugar\" },{ \"id\": \"5007\", \"type\": \"Powdered Sugar\" },{ \"id\": \"5006\", \"type\": \"Chocolate with Sprinkles\" },{ \"id\": \"5003\", \"type\": \"Chocolate\" },{ \"id\": \"5004\", \"type\": \"Maple\" }]}]}}\"\"\"\n", "\n", "def fn(\n", "    text1,\n", "    text2,\n", "    num,\n", "    slider1,\n", "    slider2,\n", "    single_checkbox,\n", "    checkboxes,\n", "    radio,\n", "    dropdown,\n", "    multi_dropdown,\n", "    im1,\n", "    # im2,\n", "    # im3,\n", "    im4,\n", "    video,\n", "    audio1,\n", "    audio2,\n", "    file,\n", "    df1,\n", "    time,\n", "):\n", "    return (\n", "        (text1 if single_checkbox else text2)\n", "        + \", selected:\"\n", "        + \", \".join(checkboxes),  # Text\n", "        {\n", "            \"positive\": num / (num + slider1 + slider2),\n", "            \"negative\": slider1 / (num + slider1 + slider2),\n", "            \"neutral\": slider2 / (num + slider1 + slider2),\n", "        },  # Label\n", "        (audio1[0], np.flipud(audio1[1]))\n", "        if audio1 is not None\n", "        else get_audio(\"cantina.wav\"),  # Audio\n", "        np.flipud(im1)\n", "        if im1 is not None\n", "        else get_image(\"cheetah1.jpg\"),  # Image\n", "        video\n", "        if video is not None\n", "        else get_video(\"world.mp4\"),  # Video\n", "        [\n", "            (\"The\", \"art\"),\n", "            (\"quick brown\", \"adj\"),\n", "            (\"fox\", \"nn\"),\n", "            (\"jumped\", \"vrb\"),\n", "            (\"testing testing testing\", None),\n", "            (\"over\", \"prp\"),\n", "            (\"the\", \"art\"),\n", "            (\"testing\", None),\n", "            (\"lazy\", \"adj\"),\n", "            (\"dogs\", \"nn\"),\n", "            (\".\", \"punc\"),\n", "        ]\n", "        + [(f\"test {x}\", f\"test {x}\") for x in range(10)],  # HighlightedText\n", "        # [(\"The testing testing testing\", None), (\"quick brown\", 0.2), (\"fox\", 1), (\"jumped\", -1), (\"testing testing testing\", 0), (\"over\", 0), (\"the\", 0), (\"testing\", 0), (\"lazy\", 1), (\"dogs\", 0), (\".\", 1)] + [(f\"test {x}\",  x/10) for x in range(-10, 10)],  # HighlightedText\n", "        [\n", "            (\"The testing testing testing\", None),\n", "            (\"over\", 0.6),\n", "            (\"the\", 0.2),\n", "            (\"testing\", None),\n", "            (\"lazy\", -0.1),\n", "            (\"dogs\", 0.4),\n", "            (\".\", 0),\n", "        ]\n", "        + [(\"test\", x / 10) for x in range(-10, 10)],  # HighlightedText\n", "        json.loads(JSONOBJ),  # JSON\n", "        \"<button style='background-color: red'>Click Me: \"\n", "        + radio\n", "        + \"</button>\",  # HTML\n", "        get_file(\"titanic.csv\"),  # File\n", "        df1,  # Dataframe\n", "        np.random.randint(0, 10, (4, 4)),  # Dataframe\n", "        time, # DateTime\n", "    )\n", "\n", "demo = gr.Interface(\n", "    fn,\n", "    inputs=[\n", "        gr.Textbox(value=\"Lorem ipsum\", label=\"Textbox\"),\n", "        gr.Textbox(lines=3, placeholder=\"Type here..\", label=\"Textbox 2\"),\n", "        gr.Number(label=\"Number\", value=42),\n", "        gr.Slider(10, 20, value=15, label=\"Slider: 10 - 20\"),\n", "        gr.Slider(maximum=20, step=0.04, label=\"Slider: step @ 0.04\"),\n", "        gr.Checkbox(label=\"Checkbox\"),\n", "        gr.CheckboxGroup(label=\"CheckboxGroup\", choices=CHOICES, value=CHOICES[0:2]),\n", "        gr.Radio(label=\"Radio\", choices=CHOICES, value=CHOICES[2]),\n", "        gr.Dropdown(label=\"Dropdown\", choices=CHOICES),\n", "        gr.Dropdown(\n", "            label=\"Multiselect Dropdown (Max choice: 2)\",\n", "            choices=CHOICES,\n", "            multiselect=True,\n", "            max_choices=2,\n", "        ),\n", "        gr.Image(label=\"Image\"),\n", "        # gr.Image(label=\"Image w/ Cropper\", tool=\"select\"),\n", "        # gr.Image(label=\"Sketchpad\", source=\"canvas\"),\n", "        gr.Image(label=\"Webcam\", sources=[\"webcam\"]),\n", "        gr.Video(label=\"Video\"),\n", "        gr.Audio(label=\"Audio\"),\n", "        gr.Audio(label=\"Microphone\", sources=[\"microphone\"]),\n", "        gr.File(label=\"File\"),\n", "        gr.Dataframe(label=\"Dataframe\", headers=[\"Name\", \"Age\", \"Gender\"]),\n", "        gr.DateTime(label=\"DateTime\"),\n", "    ],\n", "    outputs=[\n", "        gr.Textbox(label=\"Textbox\"),\n", "        gr.Label(label=\"Label\"),\n", "        gr.Audio(label=\"Audio\"),\n", "        gr.Image(label=\"Image\", elem_id=\"output-img\"),\n", "        gr.Video(label=\"Video\"),\n", "        gr.HighlightedText(\n", "            label=\"HighlightedText\", color_map={\"punc\": \"pink\", \"test 0\": \"blue\"}\n", "        ),\n", "        gr.HighlightedText(label=\"HighlightedText\", show_legend=True),\n", "        gr.JSON(label=\"JSON\", show_indices=True),\n", "        gr.HTML(label=\"HTML\"),\n", "        gr.File(label=\"File\"),\n", "        gr.Dataframe(label=\"Dataframe\"),\n", "        gr.Dataframe(label=\"Numpy\"),\n", "        gr.DateTime(label=\"DateTime\"),\n", "    ],\n", "    examples=[\n", "        [\n", "            \"the quick brown fox\",\n", "            \"jumps over the lazy dog\",\n", "            10,\n", "            12,\n", "            4,\n", "            True,\n", "            [\"foo\", \"baz\"],\n", "            \"baz\",\n", "            \"bar\",\n", "            [\"foo\", \"bar\"],\n", "            get_image(\"cheetah1.jpg\"),\n", "            # get_image(\"cheetah1.jpg\"),\n", "            # get_image(\"cheetah1.jpg\"),\n", "            get_image(\"cheetah1.jpg\"),\n", "            get_video(\"world.mp4\"),\n", "            get_audio(\"cantina.wav\"),\n", "            get_audio(\"cantina.wav\"),\n", "            get_file(\"titanic.csv\"),\n", "            [[1, 2, 3, 4], [4, 5, 6, 7], [8, 9, 1, 2], [3, 4, 5, 6]],\n", "            \"2025-06-10 12:00:00\",\n", "        ]\n", "    ]\n", "    * 3,\n", "    title=\"Kitchen Sink\",\n", "    description=\"Try out all the components!\",\n", "    article=\"Learn more about [Gradio](http://gradio.app)\",\n", "    cache_examples=True,\n", ")\n", "\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

demos/kitchen_sink/run.py

@@ -0,0 +1,165 @@
+import os
+import json
+
+import numpy as np
+
+import gradio as gr
+from gradio.media import get_image, get_video, get_audio, get_file
+
+CHOICES = ["foo", "bar", "baz"]
+JSONOBJ = """{"items":{"item":[{"id": "0001","type": null,"is_good": false,"ppu": 0.55,"batters":{"batter":[{ "id": "1001", "type": "Regular" },{ "id": "1002", "type": "Chocolate" },{ "id": "1003", "type": "Blueberry" },{ "id": "1004", "type": "Devil's Food" }]},"topping":[{ "id": "5001", "type": "None" },{ "id": "5002", "type": "Glazed" },{ "id": "5005", "type": "Sugar" },{ "id": "5007", "type": "Powdered Sugar" },{ "id": "5006", "type": "Chocolate with Sprinkles" },{ "id": "5003", "type": "Chocolate" },{ "id": "5004", "type": "Maple" }]}]}}"""
+
+def fn(
+    text1,
+    text2,
+    num,
+    slider1,
+    slider2,
+    single_checkbox,
+    checkboxes,
+    radio,
+    dropdown,
+    multi_dropdown,
+    im1,
+    # im2,
+    # im3,
+    im4,
+    video,
+    audio1,
+    audio2,
+    file,
+    df1,
+    time,
+):
+    return (
+        (text1 if single_checkbox else text2)
+        + ", selected:"
+        + ", ".join(checkboxes),  # Text
+        {
+            "positive": num / (num + slider1 + slider2),
+            "negative": slider1 / (num + slider1 + slider2),
+            "neutral": slider2 / (num + slider1 + slider2),
+        },  # Label
+        (audio1[0], np.flipud(audio1[1]))
+        if audio1 is not None
+        else get_audio("cantina.wav"),  # Audio
+        np.flipud(im1)
+        if im1 is not None
+        else get_image("cheetah1.jpg"),  # Image
+        video
+        if video is not None
+        else get_video("world.mp4"),  # Video
+        [
+            ("The", "art"),
+            ("quick brown", "adj"),
+            ("fox", "nn"),
+            ("jumped", "vrb"),
+            ("testing testing testing", None),
+            ("over", "prp"),
+            ("the", "art"),
+            ("testing", None),
+            ("lazy", "adj"),
+            ("dogs", "nn"),
+            (".", "punc"),
+        ]
+        + [(f"test {x}", f"test {x}") for x in range(10)],  # HighlightedText
+        # [("The testing testing testing", None), ("quick brown", 0.2), ("fox", 1), ("jumped", -1), ("testing testing testing", 0), ("over", 0), ("the", 0), ("testing", 0), ("lazy", 1), ("dogs", 0), (".", 1)] + [(f"test {x}",  x/10) for x in range(-10, 10)],  # HighlightedText
+        [
+            ("The testing testing testing", None),
+            ("over", 0.6),
+            ("the", 0.2),
+            ("testing", None),
+            ("lazy", -0.1),
+            ("dogs", 0.4),
+            (".", 0),
+        ]
+        + [("test", x / 10) for x in range(-10, 10)],  # HighlightedText
+        json.loads(JSONOBJ),  # JSON
+        "<button style='background-color: red'>Click Me: "
+        + radio
+        + "</button>",  # HTML
+        get_file("titanic.csv"),  # File
+        df1,  # Dataframe
+        np.random.randint(0, 10, (4, 4)),  # Dataframe
+        time, # DateTime
+    )
+
+demo = gr.Interface(
+    fn,
+    inputs=[
+        gr.Textbox(value="Lorem ipsum", label="Textbox"),
+        gr.Textbox(lines=3, placeholder="Type here..", label="Textbox 2"),
+        gr.Number(label="Number", value=42),
+        gr.Slider(10, 20, value=15, label="Slider: 10 - 20"),
+        gr.Slider(maximum=20, step=0.04, label="Slider: step @ 0.04"),
+        gr.Checkbox(label="Checkbox"),
+        gr.CheckboxGroup(label="CheckboxGroup", choices=CHOICES, value=CHOICES[0:2]),
+        gr.Radio(label="Radio", choices=CHOICES, value=CHOICES[2]),
+        gr.Dropdown(label="Dropdown", choices=CHOICES),
+        gr.Dropdown(
+            label="Multiselect Dropdown (Max choice: 2)",
+            choices=CHOICES,
+            multiselect=True,
+            max_choices=2,
+        ),
+        gr.Image(label="Image"),
+        # gr.Image(label="Image w/ Cropper", tool="select"),
+        # gr.Image(label="Sketchpad", source="canvas"),
+        gr.Image(label="Webcam", sources=["webcam"]),
+        gr.Video(label="Video"),
+        gr.Audio(label="Audio"),
+        gr.Audio(label="Microphone", sources=["microphone"]),
+        gr.File(label="File"),
+        gr.Dataframe(label="Dataframe", headers=["Name", "Age", "Gender"]),
+        gr.DateTime(label="DateTime"),
+    ],
+    outputs=[
+        gr.Textbox(label="Textbox"),
+        gr.Label(label="Label"),
+        gr.Audio(label="Audio"),
+        gr.Image(label="Image", elem_id="output-img"),
+        gr.Video(label="Video"),
+        gr.HighlightedText(
+            label="HighlightedText", color_map={"punc": "pink", "test 0": "blue"}
+        ),
+        gr.HighlightedText(label="HighlightedText", show_legend=True),
+        gr.JSON(label="JSON", show_indices=True),
+        gr.HTML(label="HTML"),
+        gr.File(label="File"),
+        gr.Dataframe(label="Dataframe"),
+        gr.Dataframe(label="Numpy"),
+        gr.DateTime(label="DateTime"),
+    ],
+    examples=[
+        [
+            "the quick brown fox",
+            "jumps over the lazy dog",
+            10,
+            12,
+            4,
+            True,
+            ["foo", "baz"],
+            "baz",
+            "bar",
+            ["foo", "bar"],
+            get_image("cheetah1.jpg"),
+            # get_image("cheetah1.jpg"),
+            # get_image("cheetah1.jpg"),
+            get_image("cheetah1.jpg"),
+            get_video("world.mp4"),
+            get_audio("cantina.wav"),
+            get_audio("cantina.wav"),
+            get_file("titanic.csv"),
+            [[1, 2, 3, 4], [4, 5, 6, 7], [8, 9, 1, 2], [3, 4, 5, 6]],
+            "2025-06-10 12:00:00",
+        ]
+    ]
+    * 3,
+    title="Kitchen Sink",
+    description="Try out all the components!",
+    article="Learn more about [Gradio](http://gradio.app)",
+    cache_examples=True,
+)
+
+if __name__ == "__main__":
+    demo.launch()

demos/kitchen_sink_random/constants.py

@@ -0,0 +1,59 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import random
+from gradio.media import get_model3d
+
+def random_plot():
+    start_year = 2020
+    x = np.arange(start_year, start_year + random.randint(0, 10))
+    year_count = x.shape[0]
+    plt_format = "-"
+    fig = plt.figure()
+    ax = fig.add_subplot(111)
+    series = np.arange(0, year_count, dtype=float)
+    series = series**2
+    series += np.random.rand(year_count)
+    ax.plot(x, series, plt_format)
+    return fig
+
+highlighted_text_output_1 = [
+    {
+        "entity": "I-LOC",
+        "score": 0.9988978,
+        "index": 2,
+        "word": "Chicago",
+        "start": 5,
+        "end": 12,
+    },
+    {
+        "entity": "I-MISC",
+        "score": 0.9958592,
+        "index": 5,
+        "word": "Pakistani",
+        "start": 22,
+        "end": 31,
+    },
+]
+highlighted_text_output_2 = [
+    {
+        "entity": "I-LOC",
+        "score": 0.9988978,
+        "index": 2,
+        "word": "Chicago",
+        "start": 5,
+        "end": 12,
+    },
+    {
+        "entity": "I-LOC",
+        "score": 0.9958592,
+        "index": 5,
+        "word": "Pakistan",
+        "start": 22,
+        "end": 30,
+    },
+]
+
+highlighted_text = "Does Chicago have any Pakistani restaurants"
+
+def random_model3d():
+    return get_model3d()

demos/kitchen_sink_random/requirements.txt

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

demos/kitchen_sink_random/run.py

@@ -0,0 +1,92 @@
+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([[("hello", "hi!")], [("bye", "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))
+    ],
+)
+
+if __name__ == "__main__":
+    demo.launch()

demos/matrix_transpose/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": "302934307671667531413257853548643485645", "metadata": {}, "source": ["# Gradio Demo: matrix_transpose"]}, {"cell_type": "code", "execution_count": null, "id": "272996653310673477252411125948039410165", "metadata": {}, "outputs": [], "source": ["!pip install -q gradio "]}, {"cell_type": "code", "execution_count": null, "id": "288918539441861185822528903084949547379", "metadata": {}, "outputs": [], "source": ["import numpy as np\n", "\n", "import gradio as gr\n", "\n", "def transpose(matrix):\n", "    return matrix.T\n", "\n", "demo = gr.Interface(\n", "    transpose,\n", "    gr.Dataframe(type=\"numpy\", datatype=\"number\", row_count=5, col_count=3, show_fullscreen_button=True),\n", "    \"numpy\",\n", "    examples=[\n", "        [np.zeros((30, 30)).tolist()],\n", "        [np.ones((2, 2)).tolist()],\n", "        [np.random.randint(0, 10, (3, 10)).tolist()],\n", "        [np.random.randint(0, 10, (10, 3)).tolist()],\n", "        [np.random.randint(0, 10, (10, 10)).tolist()],\n", "    ],\n", "    cache_examples=False\n", ")\n", "\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

demos/matrix_transpose/run.py

@@ -0,0 +1,23 @@
+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, col_count=3, show_fullscreen_button=True),
+    "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
+)
+
+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.ipynb

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

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(css=str(abs_path / "assets/leaderboard_data.json"))
+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()

demos/model3D/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": "302934307671667531413257853548643485645", "metadata": {}, "source": ["# Gradio Demo: model3D"]}, {"cell_type": "code", "execution_count": null, "id": "272996653310673477252411125948039410165", "metadata": {}, "outputs": [], "source": ["!pip install -q gradio "]}, {"cell_type": "code", "execution_count": null, "id": "288918539441861185822528903084949547379", "metadata": {}, "outputs": [], "source": ["import gradio as gr\n", "# get_model3d() returns the file path to sample 3D models included with Gradio\n", "from gradio.media import get_model3d, MEDIA_ROOT\n", "\n", "\n", "def load_mesh(mesh_file_name):\n", "    return mesh_file_name\n", "\n", "\n", "demo = gr.Interface(\n", "    fn=load_mesh,\n", "    inputs=gr.Model3D(label=\"Other name\", display_mode=\"wireframe\"),\n", "    outputs=gr.Model3D(\n", "        clear_color=(0.0, 0.0, 0.0, 0.0), label=\"3D Model\", display_mode=\"wireframe\"\n", "    ),\n", "    examples=[\n", "        [get_model3d(\"Bunny.obj\")],\n", "        [get_model3d(\"Duck.glb\")],\n", "        [get_model3d(\"Fox.gltf\")],\n", "        [get_model3d(\"face.obj\")],\n", "        [get_model3d(\"sofia.stl\")],\n", "        [\n", "            \"https://huggingface.co/datasets/dylanebert/3dgs/resolve/main/bonsai/bonsai-7k-mini.splat\"\n", "        ],\n", "        [\n", "            \"https://huggingface.co/datasets/dylanebert/3dgs/resolve/main/luigi/luigi.ply\"\n", "        ],\n", "    ],\n", "    cache_examples=True,\n", ")\n", "\n", "if __name__ == \"__main__\":\n", "    demo.launch(allowed_paths=[str(MEDIA_ROOT)])\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

demos/model3D/run.py

@@ -0,0 +1,33 @@
+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,
+)
+
+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",
+            show_export_button=True,
+        )
+        temp_by_time_location = gr.BarPlot(
+            temp_sensor_data,
+            x="time",
+            y="temperature",
+            color="location",
+            show_export_button=True,
+        )
+
+    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",
+            show_export_button=True,
+        )
+        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,
+            show_export_button=True,
+        )
+        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"},
+            show_export_button=True,
+        )
+
+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,71 @@
+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",
+        show_export_button=True,
+    )
+    temp_by_time_location = gr.LinePlot(
+        temp_sensor_data,
+        x="time",
+        y="temperature",
+        color="location",
+        show_export_button=True,
+    )
+
+    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",
+        show_export_button=True,
+    )
+    with gr.Row():
+        price_by_rating = gr.LinePlot(
+            food_rating_data,
+            x="rating",
+            y="price",
+            show_export_button=True,
+        )
+        price_by_rating_color = gr.LinePlot(
+            food_rating_data,
+            x="rating",
+            y="price",
+            color="cuisine",
+            color_map={"Italian": "red", "Mexican": "green", "Chinese": "blue"},
+            show_export_button=True,
+        )
+
+if __name__ == "__main__":
+    line_plots.launch()

demos/native_plots/requirements.txt

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

demos/native_plots/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": "302934307671667531413257853548643485645", "metadata": {}, "source": ["# Gradio Demo: native_plots"]}, {"cell_type": "code", "execution_count": null, "id": "272996653310673477252411125948039410165", "metadata": {}, "outputs": [], "source": ["!pip install -q gradio vega_datasets pandas "]}, {"cell_type": "code", "execution_count": null, "id": "288918539441861185822528903084949547379", "metadata": {}, "outputs": [], "source": ["# Downloading files from the demo repo\n", "import os\n", "!wget -q https://github.com/gradio-app/gradio/raw/main/demo/native_plots/bar_plot_demo.py\n", "!wget -q https://github.com/gradio-app/gradio/raw/main/demo/native_plots/data.py\n", "!wget -q https://github.com/gradio-app/gradio/raw/main/demo/native_plots/line_plot_demo.py\n", "!wget -q https://github.com/gradio-app/gradio/raw/main/demo/native_plots/scatter_plot_demo.py"]}, {"cell_type": "code", "execution_count": null, "id": "44380577570523278879349135829904343037", "metadata": {}, "outputs": [], "source": ["import gradio as gr\n", "\n", "from scatter_plot_demo import scatter_plots  # type: ignore\n", "from line_plot_demo import line_plots  # type: ignore\n", "from bar_plot_demo import bar_plots  # type: ignore\n", "\n", "with gr.Blocks() as demo:\n", "    with gr.Tabs():\n", "        with gr.TabItem(\"Line Plot\"):\n", "            line_plots.render()\n", "        with gr.TabItem(\"Scatter Plot\"):\n", "            scatter_plots.render()\n", "        with gr.TabItem(\"Bar Plot\"):\n", "            bar_plots.render()\n", "\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

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,72 @@
+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",
+        show_export_button=True,
+    )
+    temp_by_time_location = gr.ScatterPlot(
+        temp_sensor_data,
+        x="time",
+        y="temperature",
+        color="location",
+        show_export_button=True,
+    )
+
+    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",
+        show_export_button=True,
+    )
+    with gr.Row():
+        price_by_rating = gr.ScatterPlot(
+            food_rating_data,
+            x="rating",
+            y="price",
+            color="wait",
+            show_actions_button=True,
+            show_export_button=True,
+        )
+        price_by_rating_color = gr.ScatterPlot(
+            food_rating_data,
+            x="rating",
+            y="price",
+            color="cuisine",
+            show_export_button=True,
+        )
+
+if __name__ == "__main__":
+    scatter_plots.launch()

demos/reverse_audio/requirements.txt

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

demos/reverse_audio/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": "302934307671667531413257853548643485645", "metadata": {}, "source": ["# Gradio Demo: reverse_audio"]}, {"cell_type": "code", "execution_count": null, "id": "272996653310673477252411125948039410165", "metadata": {}, "outputs": [], "source": ["!pip install -q gradio numpy "]}, {"cell_type": "code", "execution_count": null, "id": "288918539441861185822528903084949547379", "metadata": {}, "outputs": [], "source": ["\n", "import numpy as np\n", "\n", "import gradio as gr\n", "\n", "def reverse_audio(audio):\n", "    sr, data = audio\n", "    return (sr, np.flipud(data))\n", "\n", "input_audio = gr.Audio(\n", "    sources=[\"microphone\"],\n", "    waveform_options=gr.WaveformOptions(\n", "        waveform_color=\"#01C6FF\",\n", "        waveform_progress_color=\"#0066B4\",\n", "        skip_length=2,\n", "        show_controls=False,\n", "    ),\n", ")\n", "demo = gr.Interface(\n", "    fn=reverse_audio,\n", "    inputs=input_audio,\n", "    outputs=\"audio\"\n", ")\n", "\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

demos/reverse_audio/run.py

@@ -0,0 +1,26 @@
+
+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_controls=False,
+    ),
+)
+demo = gr.Interface(
+    fn=reverse_audio,
+    inputs=input_audio,
+    outputs="audio"
+)
+
+if __name__ == "__main__":
+    demo.launch()

demos/stream_audio/requirements.txt

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

demos/stream_audio/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": "302934307671667531413257853548643485645", "metadata": {}, "source": ["# Gradio Demo: stream_audio"]}, {"cell_type": "code", "execution_count": null, "id": "272996653310673477252411125948039410165", "metadata": {}, "outputs": [], "source": ["!pip install -q gradio numpy "]}, {"cell_type": "code", "execution_count": null, "id": "288918539441861185822528903084949547379", "metadata": {}, "outputs": [], "source": ["import gradio as gr\n", "import numpy as np\n", "import time\n", "\n", "def add_to_stream(audio, instream):\n", "    time.sleep(1)\n", "    if audio is None:\n", "        return gr.Audio(), instream\n", "    if instream is None:\n", "        ret = audio\n", "    else:\n", "        ret = (audio[0], np.concatenate((instream[1], audio[1])))\n", "    return ret, ret\n", "\n", "with gr.Blocks() as demo:\n", "    inp = gr.Audio(sources=[\"microphone\"])\n", "    out = gr.Audio()\n", "    stream = gr.State()\n", "    clear = gr.Button(\"Clear\")\n", "\n", "    inp.stream(add_to_stream, [inp, stream], [out, stream])\n", "    clear.click(lambda: [None, None, None], None, [inp, out, stream])\n", "\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

demos/stream_audio/run.py

@@ -0,0 +1,25 @@
+import gradio as gr
+import numpy as np
+import time
+
+def add_to_stream(audio, instream):
+    time.sleep(1)
+    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_frames/requirements.txt

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

demos/stream_frames/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": "302934307671667531413257853548643485645", "metadata": {}, "source": ["# Gradio Demo: stream_frames"]}, {"cell_type": "code", "execution_count": null, "id": "272996653310673477252411125948039410165", "metadata": {}, "outputs": [], "source": ["!pip install -q gradio numpy "]}, {"cell_type": "code", "execution_count": null, "id": "288918539441861185822528903084949547379", "metadata": {}, "outputs": [], "source": ["import gradio as gr\n", "import numpy as np\n", "\n", "def flip(im):\n", "    return np.flipud(im)\n", "\n", "demo = gr.Interface(\n", "    flip,\n", "    gr.Image(sources=[\"webcam\"], streaming=True),\n", "    \"image\",\n", "    live=True\n", ")\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

demos/stream_frames/run.py

@@ -0,0 +1,14 @@
+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
+)
+if __name__ == "__main__":
+    demo.launch()

demos/stt_or_tts/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": "302934307671667531413257853548643485645", "metadata": {}, "source": ["# Gradio Demo: stt_or_tts"]}, {"cell_type": "code", "execution_count": null, "id": "272996653310673477252411125948039410165", "metadata": {}, "outputs": [], "source": ["!pip install -q gradio "]}, {"cell_type": "code", "execution_count": null, "id": "288918539441861185822528903084949547379", "metadata": {}, "outputs": [], "source": ["import gradio as gr\n", "\n", "tts_examples = [\n", "    \"I love learning machine learning\",\n", "    \"How do you do?\",\n", "]\n", "\n", "tts_demo = gr.load(\n", "    \"huggingface/facebook/fastspeech2-en-ljspeech\",\n", "    title=None,\n", "    examples=tts_examples,\n", "    description=\"Give me something to say!\",\n", "    cache_examples=False\n", ")\n", "\n", "stt_demo = gr.load(\n", "    \"huggingface/facebook/wav2vec2-base-960h\",\n", "    title=None,\n", "    inputs=gr.Microphone(type=\"filepath\"),\n", "    description=\"Let me try to guess what you're saying!\",\n", "    cache_examples=False\n", ")\n", "\n", "demo = gr.TabbedInterface([tts_demo, stt_demo], [\"Text-to-speech\", \"Speech-to-text\"])\n", "\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

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.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": "302934307671667531413257853548643485645", "metadata": {}, "source": ["# Gradio Demo: video_component"]}, {"cell_type": "code", "execution_count": null, "id": "272996653310673477252411125948039410165", "metadata": {}, "outputs": [], "source": ["!pip install -q gradio "]}, {"cell_type": "code", "execution_count": null, "id": "288918539441861185822528903084949547379", "metadata": {}, "outputs": [], "source": ["import gradio as gr\n", "# get_video() returns the file path to sample videos included with Gradio\n", "from gradio.media import get_video\n", "\n", "demo = gr.Interface(\n", "    fn=lambda x: x,\n", "    inputs=gr.Video(),\n", "    outputs=gr.Video(),\n", "    examples=[\n", "        [get_video(\"world.mp4\")],\n", "        [get_video(\"a.mp4\")],\n", "        [get_video(\"b.mp4\")],\n", "    ],\n", "    cache_examples=True\n", ")\n", "\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

demos/video_component/run.py

@@ -0,0 +1,18 @@
+import gradio as gr
+# get_video() returns the file path to sample videos included with Gradio
+from gradio.media import get_video
+
+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")],
+    ],
+    cache_examples=True
+)
+
+if __name__ == "__main__":
+    demo.launch()

demos/zip_files/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": "302934307671667531413257853548643485645", "metadata": {}, "source": ["# Gradio Demo: zip_files"]}, {"cell_type": "code", "execution_count": null, "id": "272996653310673477252411125948039410165", "metadata": {}, "outputs": [], "source": ["!pip install -q gradio "]}, {"cell_type": "code", "execution_count": null, "id": "288918539441861185822528903084949547379", "metadata": {}, "outputs": [], "source": ["from zipfile import ZipFile\n", "\n", "import gradio as gr\n", "\n", "def zip_files(files):\n", "    with ZipFile(\"tmp.zip\", \"w\") as zip_obj:\n", "        for file in files:\n", "            zip_obj.write(file.name, file.name.split(\"/\")[-1])\n", "    return \"tmp.zip\"\n", "\n", "demo = gr.Interface(\n", "    zip_files,\n", "    gr.File(file_count=\"multiple\", file_types=[\"text\", \".json\", \".csv\"]),\n", "    \"file\",\n", "    examples=[[[gr.get_file(\"titanic.csv\"),\n", "    gr.get_file(\"titanic.csv\"),\n", "    gr.get_file(\"titanic.csv\")]]],\n", "    cache_examples=True\n", ")\n", "\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

demos/zip_files/run.py

@@ -0,0 +1,22 @@
+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
+)
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,7 @@
+gradio-client @ git+https://github.com/gradio-app/gradio@4d07126427e395fcc058b1a3a30113aac3ca036e#subdirectory=client/python
+https://gradio-pypi-previews.s3.amazonaws.com/4d07126427e395fcc058b1a3a30113aac3ca036e/gradio-5.49.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)])