Upload folder using huggingface_hub

demos/clear_components/run.ipynb

@@ -1 +1 @@
-{"cells": [{"cell_type": "markdown", "id": "302934307671667531413257853548643485645", "metadata": {}, "source": ["# Gradio Demo: clear_components"]}, {"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": ["# Downloading files from the demo repo\n", "import os\n", "!wget -q https://github.com/gradio-app/gradio/raw/main/demo/clear_components/__init__.py"]}, {"cell_type": "code", "execution_count": null, "id": "44380577570523278879349135829904343037", "metadata": {}, "outputs": [], "source": ["import gradio as gr\n", "from datetime import datetime\n", "import os\n", "import random\n", "import string\n", "import pandas as pd\n", "\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", "\n", "\n", "def random_plot():\n", "    start_year = 2020\n", "    x = np.arange(start_year, start_year + 5)\n", "    year_count = x.shape[0]\n", "    plt_format = \"-\"\n", "    fig = plt.figure()\n", "    ax = fig.add_subplot(111)\n", "    series = np.arange(0, year_count, dtype=float)\n", "    series = series**2\n", "    series += np.random.rand(year_count)\n", "    ax.plot(x, series, plt_format)\n", "    return fig\n", "\n", "\n", "images = [\n", "    \"https://images.unsplash.com/photo-1507003211169-0a1dd7228f2d?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8&auto=format&fit=crop&w=387&q=80\",\n", "    \"https://images.unsplash.com/photo-1554151228-14d9def656e4?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8&auto=format&fit=crop&w=386&q=80\",\n", "    \"https://images.unsplash.com/photo-1542909168-82c3e7fdca5c?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxzZWFyY2h8MXx8aHVtYW4lMjBmYWNlfGVufDB8fDB8fA%3D%3D&w=1000&q=80\",\n", "]\n", "file_dir = os.path.join(os.path.abspath(''), \"..\", \"kitchen_sink\", \"files\")\n", "model3d_dir = os.path.join(os.path.abspath(''), \"..\", \"model3D\", \"files\")\n", "highlighted_text_output_1 = [\n", "    {\n", "        \"entity\": \"I-LOC\",\n", "        \"score\": 0.9988978,\n", "        \"index\": 2,\n", "        \"word\": \"Chicago\",\n", "        \"start\": 5,\n", "        \"end\": 12,\n", "    },\n", "    {\n", "        \"entity\": \"I-MISC\",\n", "        \"score\": 0.9958592,\n", "        \"index\": 5,\n", "        \"word\": \"Pakistani\",\n", "        \"start\": 22,\n", "        \"end\": 31,\n", "    },\n", "]\n", "highlighted_text_output_2 = [\n", "    {\n", "        \"entity\": \"I-LOC\",\n", "        \"score\": 0.9988978,\n", "        \"index\": 2,\n", "        \"word\": \"Chicago\",\n", "        \"start\": 5,\n", "        \"end\": 12,\n", "    },\n", "    {\n", "        \"entity\": \"I-LOC\",\n", "        \"score\": 0.9958592,\n", "        \"index\": 5,\n", "        \"word\": \"Pakistan\",\n", "        \"start\": 22,\n", "        \"end\": 30,\n", "    },\n", "]\n", "\n", "highlighted_text = \"Does Chicago have any Pakistani restaurants\"\n", "\n", "\n", "def random_model3d():\n", "    model_3d = random.choice(\n", "        [os.path.join(model3d_dir, model) for model in os.listdir(model3d_dir) if model != \"source.txt\"]\n", "    )\n", "    return model_3d\n", "\n", "\n", "\n", "components = [\n", "    gr.Textbox(value=lambda: datetime.now(), label=\"Current Time\"),\n", "    gr.Number(value=lambda: random.random(), label=\"Random Percentage\"),\n", "    gr.Slider(minimum=0, maximum=100, randomize=True, label=\"Slider with randomize\"),\n", "    gr.Slider(\n", "        minimum=0,\n", "        maximum=1,\n", "        value=lambda: random.random(),\n", "        label=\"Slider with value func\",\n", "    ),\n", "    gr.Checkbox(value=lambda: random.random() > 0.5, label=\"Random Checkbox\"),\n", "    gr.CheckboxGroup(\n", "        choices=[\"a\", \"b\", \"c\", \"d\"],\n", "        value=lambda: random.choice([\"a\", \"b\", \"c\", \"d\"]),\n", "        label=\"Random CheckboxGroup\",\n", "    ),\n", "    gr.Radio(\n", "        choices=list(string.ascii_lowercase),\n", "        value=lambda: random.choice(string.ascii_lowercase),\n", "    ),\n", "    gr.Dropdown(\n", "        choices=[\"a\", \"b\", \"c\", \"d\", \"e\"],\n", "        value=lambda: random.choice([\"a\", \"b\", \"c\"]),\n", "    ),\n", "    gr.Image(\n", "        value=lambda: random.choice(images)\n", "    ),\n", "    gr.Video(value=lambda: os.path.join(file_dir, \"world.mp4\")),\n", "    gr.Audio(value=lambda: os.path.join(file_dir, \"cantina.wav\")),\n", "    gr.File(\n", "        value=lambda: random.choice(\n", "            [os.path.join(file_dir, img) for img in os.listdir(file_dir)]\n", "        )\n", "    ),\n", "    gr.Dataframe(\n", "        value=lambda: pd.DataFrame({\"random_number_rows\": range(5)}, columns=[\"one\", \"two\", \"three\"])\n", "    ),\n", "    gr.ColorPicker(value=lambda: random.choice([\"#000000\", \"#ff0000\", \"#0000FF\"])),\n", "    gr.Label(value=lambda: random.choice([\"Pedestrian\", \"Car\", \"Cyclist\"])),\n", "    gr.HighlightedText(\n", "        value=lambda: random.choice(\n", "            [\n", "                {\"text\": highlighted_text, \"entities\": highlighted_text_output_1},\n", "                {\"text\": highlighted_text, \"entities\": highlighted_text_output_2},\n", "            ]\n", "        ),\n", "    ),\n", "    gr.JSON(value=lambda: random.choice([{\"a\": 1}, {\"b\": 2}])),\n", "    gr.HTML(\n", "        value=lambda: random.choice(\n", "            [\n", "                '<p style=\"color:red;\">I am red</p>',\n", "                '<p style=\"color:blue;\">I am blue</p>',\n", "            ]\n", "        )\n", "    ),\n", "    gr.Gallery(\n", "        value=lambda: images\n", "    ),\n", "    gr.Model3D(value=random_model3d),\n", "    gr.Plot(value=random_plot),\n", "    gr.Markdown(value=lambda: f\"### {random.choice(['Hello', 'Hi', 'Goodbye!'])}\"),\n", "]\n", "\n", "\n", "def evaluate_values(*args):\n", "    are_false = []\n", "    for a in args:\n", "        if isinstance(a, (pd.DataFrame, np.ndarray)):\n", "            are_false.append(not a.any().any())\n", "        elif isinstance(a, str) and a.startswith(\"#\"):\n", "            are_false.append(a == \"#000000\")\n", "        else:\n", "            are_false.append(not a)\n", "    return all(are_false)\n", "\n", "\n", "with gr.Blocks() as demo:\n", "    for i, component in enumerate(components):\n", "        component.label = f\"component_{str(i).zfill(2)}\"\n", "        component.render()\n", "    clear = gr.ClearButton(value=\"Clear\", components=components)\n", "    result = gr.Textbox(label=\"Are all cleared?\")\n", "    hide = gr.Button(value=\"Hide\")\n", "    reveal = gr.Button(value=\"Reveal\")\n", "    clear_button_and_components = components + [clear]\n", "    hide.click(\n", "        lambda: [c.__class__(visible=False) for c in clear_button_and_components],\n", "        inputs=[],\n", "        outputs=clear_button_and_components\n", "    )\n", "    reveal.click(\n", "        lambda: [c.__class__(visible=True) for c in clear_button_and_components],\n", "        inputs=[],\n", "        outputs=clear_button_and_components\n", "    )\n", "    get_value = gr.Button(value=\"Get Values\")\n", "    get_value.click(evaluate_values, components, result)\n", "\n", "\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}
+{"cells": [{"cell_type": "markdown", "id": "302934307671667531413257853548643485645", "metadata": {}, "source": ["# Gradio Demo: clear_components"]}, {"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": ["# Downloading files from the demo repo\n", "import os\n", "!wget -q https://github.com/gradio-app/gradio/raw/main/demo/clear_components/__init__.py"]}, {"cell_type": "code", "execution_count": null, "id": "44380577570523278879349135829904343037", "metadata": {}, "outputs": [], "source": ["import gradio as gr\n", "from datetime import datetime\n", "import os\n", "import random\n", "import string\n", "import pandas as pd\n", "\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", "\n", "\n", "def random_plot():\n", "    start_year = 2020\n", "    x = np.arange(start_year, start_year + 5)\n", "    year_count = x.shape[0]\n", "    plt_format = \"-\"\n", "    fig = plt.figure()\n", "    ax = fig.add_subplot(111)\n", "    series = np.arange(0, year_count, dtype=float)\n", "    series = series**2\n", "    series += np.random.rand(year_count)\n", "    ax.plot(x, series, plt_format)\n", "    return fig\n", "\n", "\n", "images = [\n", "    \"https://images.unsplash.com/photo-1507003211169-0a1dd7228f2d?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8&auto=format&fit=crop&w=387&q=80\",\n", "    \"https://images.unsplash.com/photo-1554151228-14d9def656e4?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8&auto=format&fit=crop&w=386&q=80\",\n", "    \"https://images.unsplash.com/photo-1542909168-82c3e7fdca5c?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxzZWFyY2h8MXx8aHVtYW4lMjBmYWNlfGVufDB8fDB8fA%3D%3D&w=1000&q=80\",\n", "]\n", "file_dir = os.path.join(os.path.abspath(''), \"..\", \"kitchen_sink\", \"files\")\n", "model3d_dir = os.path.join(os.path.abspath(''), \"..\", \"model3D\", \"files\")\n", "highlighted_text_output_1 = [\n", "    {\n", "        \"entity\": \"I-LOC\",\n", "        \"score\": 0.9988978,\n", "        \"index\": 2,\n", "        \"word\": \"Chicago\",\n", "        \"start\": 5,\n", "        \"end\": 12,\n", "    },\n", "    {\n", "        \"entity\": \"I-MISC\",\n", "        \"score\": 0.9958592,\n", "        \"index\": 5,\n", "        \"word\": \"Pakistani\",\n", "        \"start\": 22,\n", "        \"end\": 31,\n", "    },\n", "]\n", "highlighted_text_output_2 = [\n", "    {\n", "        \"entity\": \"I-LOC\",\n", "        \"score\": 0.9988978,\n", "        \"index\": 2,\n", "        \"word\": \"Chicago\",\n", "        \"start\": 5,\n", "        \"end\": 12,\n", "    },\n", "    {\n", "        \"entity\": \"I-LOC\",\n", "        \"score\": 0.9958592,\n", "        \"index\": 5,\n", "        \"word\": \"Pakistan\",\n", "        \"start\": 22,\n", "        \"end\": 30,\n", "    },\n", "]\n", "\n", "highlighted_text = \"Does Chicago have any Pakistani restaurants\"\n", "\n", "\n", "def random_model3d():\n", "    model_3d = random.choice(\n", "        [os.path.join(model3d_dir, model) for model in os.listdir(model3d_dir) if model != \"source.txt\"]\n", "    )\n", "    return model_3d\n", "\n", "\n", "\n", "components = [\n", "    gr.Textbox(value=lambda: datetime.now(), label=\"Current Time\"),\n", "    gr.Number(value=lambda: random.random(), label=\"Random Percentage\"),\n", "    gr.Slider(minimum=0, maximum=100, randomize=True, label=\"Slider with randomize\"),\n", "    gr.Slider(\n", "        minimum=0,\n", "        maximum=1,\n", "        value=lambda: random.random(),\n", "        label=\"Slider with value func\",\n", "    ),\n", "    gr.Checkbox(value=lambda: random.random() > 0.5, label=\"Random Checkbox\"),\n", "    gr.CheckboxGroup(\n", "        choices=[\"a\", \"b\", \"c\", \"d\"],\n", "        value=lambda: random.choice([\"a\", \"b\", \"c\", \"d\"]),\n", "        label=\"Random CheckboxGroup\",\n", "    ),\n", "    gr.Radio(\n", "        choices=list(string.ascii_lowercase),\n", "        value=lambda: random.choice(string.ascii_lowercase),\n", "    ),\n", "    gr.Dropdown(\n", "        choices=[\"a\", \"b\", \"c\", \"d\", \"e\"],\n", "        value=lambda: random.choice([\"a\", \"b\", \"c\"]),\n", "    ),\n", "    gr.Image(\n", "        value=lambda: random.choice(images)\n", "    ),\n", "    gr.Video(value=lambda: os.path.join(file_dir, \"world.mp4\")),\n", "    gr.Audio(value=lambda: os.path.join(file_dir, \"cantina.wav\")),\n", "    gr.File(\n", "        value=lambda: random.choice(\n", "            [os.path.join(file_dir, img) for img in os.listdir(file_dir)]\n", "        )\n", "    ),\n", "    gr.Dataframe(\n", "        value=lambda: pd.DataFrame({\"random_number_rows\": range(5)}, columns=[\"one\", \"two\", \"three\"])  # type: ignore\n", "    ),\n", "    gr.ColorPicker(value=lambda: random.choice([\"#000000\", \"#ff0000\", \"#0000FF\"])),\n", "    gr.Label(value=lambda: random.choice([\"Pedestrian\", \"Car\", \"Cyclist\"])),\n", "    gr.HighlightedText(\n", "        value=lambda: random.choice(\n", "            [\n", "                {\"text\": highlighted_text, \"entities\": highlighted_text_output_1},\n", "                {\"text\": highlighted_text, \"entities\": highlighted_text_output_2},\n", "            ]\n", "        ),\n", "    ),\n", "    gr.JSON(value=lambda: random.choice([{\"a\": 1}, {\"b\": 2}])),\n", "    gr.HTML(\n", "        value=lambda: random.choice(\n", "            [\n", "                '<p style=\"color:red;\">I am red</p>',\n", "                '<p style=\"color:blue;\">I am blue</p>',\n", "            ]\n", "        )\n", "    ),\n", "    gr.Gallery(\n", "        value=lambda: images\n", "    ),\n", "    gr.Model3D(value=random_model3d),\n", "    gr.Plot(value=random_plot),\n", "    gr.Markdown(value=lambda: f\"### {random.choice(['Hello', 'Hi', 'Goodbye!'])}\"),\n", "]\n", "\n", "\n", "def evaluate_values(*args):\n", "    are_false = []\n", "    for a in args:\n", "        if isinstance(a, (pd.DataFrame, np.ndarray)):\n", "            are_false.append(not a.any().any())  # type: ignore\n", "        elif isinstance(a, str) and a.startswith(\"#\"):\n", "            are_false.append(a == \"#000000\")\n", "        else:\n", "            are_false.append(not a)\n", "    return all(are_false)\n", "\n", "\n", "with gr.Blocks() as demo:\n", "    for i, component in enumerate(components):\n", "        component.label = f\"component_{str(i).zfill(2)}\"\n", "        component.render()\n", "    clear = gr.ClearButton(value=\"Clear\", components=components)\n", "    result = gr.Textbox(label=\"Are all cleared?\")\n", "    hide = gr.Button(value=\"Hide\")\n", "    reveal = gr.Button(value=\"Reveal\")\n", "    clear_button_and_components = components + [clear]\n", "    hide.click(\n", "        lambda: [c.__class__(visible=False) for c in clear_button_and_components],\n", "        inputs=[],\n", "        outputs=clear_button_and_components\n", "    )\n", "    reveal.click(\n", "        lambda: [c.__class__(visible=True) for c in clear_button_and_components],\n", "        inputs=[],\n", "        outputs=clear_button_and_components\n", "    )\n", "    get_value = gr.Button(value=\"Get Values\")\n", "    get_value.click(evaluate_values, components, result)\n", "\n", "\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

demos/clear_components/run.py

@@ -114,7 +114,7 @@ components = [
         )
     ),
     gr.Dataframe(
-        value=lambda: pd.DataFrame({"random_number_rows": range(5)}, columns=["one", "two", "three"])
+        value=lambda: pd.DataFrame({"random_number_rows": range(5)}, columns=["one", "two", "three"])  # type: ignore
     ),
     gr.ColorPicker(value=lambda: random.choice(["#000000", "#ff0000", "#0000FF"])),
     gr.Label(value=lambda: random.choice(["Pedestrian", "Car", "Cyclist"])),
@@ -148,7 +148,7 @@ def evaluate_values(*args):
     are_false = []
     for a in args:
         if isinstance(a, (pd.DataFrame, np.ndarray)):
-            are_false.append(not a.any().any())
+            are_false.append(not a.any().any())  # type: ignore
         elif isinstance(a, str) and a.startswith("#"):
             are_false.append(a == "#000000")
         else:

demos/mini_leaderboard/run.ipynb

@@ -1 +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 "]}, {"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": ["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", "\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", "\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)\n", "    filtered_df = filter_queries(query, filtered_df)\n", "    df = select_columns(filtered_df, columns)\n", "    return df\n", "\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))]\n", "\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\n", "\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(\n", "                subset=[\"Model\", \"Precision\", \"Model sha\"]\n", "            )\n", "\n", "    return filtered_df\n", "\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])\n", "    )\n", "    params_column = pd.to_numeric(df[\"#Params (B)\"], errors=\"coerce\")\n", "    mask = params_column.apply(lambda x: any(numeric_interval.contains(x)))\n", "    filtered_df = filtered_df.loc[mask]\n", "\n", "    return filtered_df\n", "\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],\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],\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", "\n", "if __name__ == \"__main__\":\n", "    demo.queue(default_concurrency_limit=40).launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}
+{"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 "]}, {"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": ["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", "\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", "\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", "\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", "\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", "\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", "\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", "\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],\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],\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", "\n", "if __name__ == \"__main__\":\n", "    demo.queue(default_concurrency_limit=40).launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

demos/mini_leaderboard/run.py

@@ -87,20 +87,20 @@ def update_table(
     size_query: list,
     query: str,
 ):
-    filtered_df = filter_models(hidden_df, type_query, size_query, precision_query)
+    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))]
+    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
+    return filtered_df  # type: ignore
 
 
 def filter_queries(query: str, filtered_df: pd.DataFrame) -> pd.DataFrame:
@@ -115,7 +115,7 @@ def filter_queries(query: str, filtered_df: pd.DataFrame) -> pd.DataFrame:
                     final_df.append(temp_filtered_df)
         if len(final_df) > 0:
             filtered_df = pd.concat(final_df)
-            filtered_df = filtered_df.drop_duplicates(
+            filtered_df = filtered_df.drop_duplicates(  # type: ignore
                 subset=["Model", "Precision", "Model sha"]
             )
 
@@ -136,10 +136,10 @@ def filter_models(
     filtered_df = filtered_df.loc[df["Precision"].isin(precision_query + ["None"])]
 
     numeric_interval = pd.IntervalIndex(
-        sorted([NUMERIC_INTERVALS[s] for s in size_query])
+        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)))
+    mask = params_column.apply(lambda x: any(numeric_interval.contains(x)))  # type: ignore
     filtered_df = filtered_df.loc[mask]
 
     return filtered_df

demos/model3D/run.ipynb

@@ -1 +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": ["# Downloading files from the demo repo\n", "import os\n", "os.mkdir('files')\n", "!wget -q -O files/Bunny.obj https://github.com/gradio-app/gradio/raw/main/demo/model3D/files/Bunny.obj\n", "!wget -q -O files/Duck.glb https://github.com/gradio-app/gradio/raw/main/demo/model3D/files/Duck.glb\n", "!wget -q -O files/Fox.gltf https://github.com/gradio-app/gradio/raw/main/demo/model3D/files/Fox.gltf\n", "!wget -q -O files/face.obj https://github.com/gradio-app/gradio/raw/main/demo/model3D/files/face.obj\n", "!wget -q -O files/sofia.stl https://github.com/gradio-app/gradio/raw/main/demo/model3D/files/sofia.stl\n", "!wget -q -O files/source.txt https://github.com/gradio-app/gradio/raw/main/demo/model3D/files/source.txt"]}, {"cell_type": "code", "execution_count": null, "id": "44380577570523278879349135829904343037", "metadata": {}, "outputs": [], "source": ["import gradio as gr\n", "import os\n", "\n", "\n", "def load_mesh(mesh_file_name):\n", "    return mesh_file_name\n", "\n", "demo = gr.Interface(\n", "    fn=load_mesh,\n", "    inputs=gr.Model3D(),\n", "    outputs=gr.Model3D(\n", "            clear_color=[0.0, 0.0, 0.0, 0.0],  label=\"3D Model\", display_mode=\"wireframe\"),\n", "    examples=[\n", "        [os.path.join(os.path.abspath(''), \"files/Bunny.obj\")],\n", "        [os.path.join(os.path.abspath(''), \"files/Duck.glb\")],\n", "        [os.path.join(os.path.abspath(''), \"files/Fox.gltf\")],\n", "        [os.path.join(os.path.abspath(''), \"files/face.obj\")],\n", "        [os.path.join(os.path.abspath(''), \"files/sofia.stl\")],\n", "        [\"https://huggingface.co/datasets/dylanebert/3dgs/resolve/main/bonsai/bonsai-7k-mini.splat\"],\n", "        [\"https://huggingface.co/datasets/dylanebert/3dgs/resolve/main/luigi/luigi.ply\"],\n", "    ],\n", "    cache_examples=True\n", ")\n", "\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}
+{"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": ["# Downloading files from the demo repo\n", "import os\n", "os.mkdir('files')\n", "!wget -q -O files/Bunny.obj https://github.com/gradio-app/gradio/raw/main/demo/model3D/files/Bunny.obj\n", "!wget -q -O files/Duck.glb https://github.com/gradio-app/gradio/raw/main/demo/model3D/files/Duck.glb\n", "!wget -q -O files/Fox.gltf https://github.com/gradio-app/gradio/raw/main/demo/model3D/files/Fox.gltf\n", "!wget -q -O files/face.obj https://github.com/gradio-app/gradio/raw/main/demo/model3D/files/face.obj\n", "!wget -q -O files/sofia.stl https://github.com/gradio-app/gradio/raw/main/demo/model3D/files/sofia.stl\n", "!wget -q -O files/source.txt https://github.com/gradio-app/gradio/raw/main/demo/model3D/files/source.txt"]}, {"cell_type": "code", "execution_count": null, "id": "44380577570523278879349135829904343037", "metadata": {}, "outputs": [], "source": ["import gradio as gr\n", "import os\n", "\n", "\n", "def load_mesh(mesh_file_name):\n", "    return mesh_file_name\n", "\n", "demo = gr.Interface(\n", "    fn=load_mesh,\n", "    inputs=gr.Model3D(),\n", "    outputs=gr.Model3D(\n", "            clear_color=(0.0, 0.0, 0.0, 0.0),  label=\"3D Model\", display_mode=\"wireframe\"),\n", "    examples=[\n", "        [os.path.join(os.path.abspath(''), \"files/Bunny.obj\")],\n", "        [os.path.join(os.path.abspath(''), \"files/Duck.glb\")],\n", "        [os.path.join(os.path.abspath(''), \"files/Fox.gltf\")],\n", "        [os.path.join(os.path.abspath(''), \"files/face.obj\")],\n", "        [os.path.join(os.path.abspath(''), \"files/sofia.stl\")],\n", "        [\"https://huggingface.co/datasets/dylanebert/3dgs/resolve/main/bonsai/bonsai-7k-mini.splat\"],\n", "        [\"https://huggingface.co/datasets/dylanebert/3dgs/resolve/main/luigi/luigi.ply\"],\n", "    ],\n", "    cache_examples=True\n", ")\n", "\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

demos/model3D/run.py

@@ -9,7 +9,7 @@ demo = gr.Interface(
     fn=load_mesh,
     inputs=gr.Model3D(),
     outputs=gr.Model3D(
-            clear_color=[0.0, 0.0, 0.0, 0.0],  label="3D Model", display_mode="wireframe"),
+            clear_color=(0.0, 0.0, 0.0, 0.0),  label="3D Model", display_mode="wireframe"),
     examples=[
         [os.path.join(os.path.dirname(__file__), "files/Bunny.obj")],
         [os.path.join(os.path.dirname(__file__), "files/Duck.glb")],

demos/native_plots/bar_plot_demo.py

@@ -1,111 +1,77 @@
 import gradio as gr
-import pandas as pd
+import numpy as np
+from data import temp_sensor_data, food_rating_data
 
-from vega_datasets import data
+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")
 
-barley = data.barley()
-simple = pd.DataFrame({
-    'a': ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I'],
-    'b': [28, 55, 43, 91, 81, 53, 19, 87, 52]
-})
+    temp_by_time = gr.BarPlot(
+        temp_sensor_data,
+        x="time",
+        y="temperature",
+    )
+    temp_by_time_location = gr.BarPlot(
+        temp_sensor_data,
+        x="time",
+        y="temperature",
+        color="location",
+    )
 
-def bar_plot_fn(display):
-    if display == "simple":
-        return gr.BarPlot(
-            simple,
-            x="a",
-            y="b",
-            color=None,
-            group=None,
-            title="Simple Bar Plot with made up data",
-            tooltip=['a', 'b'],
-            y_lim=[20, 100],
-            x_title=None,
-            y_title=None,
-            vertical=True,
-        )
-    elif display == "stacked":
-        return gr.BarPlot(
-            barley,
-            x="variety",
-            y="yield",
-            color="site",
-            group=None,
-            title="Barley Yield Data",
-            tooltip=['variety', 'site'],
-            y_lim=None,
-            x_title=None,
-            y_title=None,
-            vertical=True,
-        )
-    elif display == "grouped":
-        return gr.BarPlot(
-            barley.astype({"year": str}),
-            x="year",
-            y="yield",
-            color="year",
-            group="site",
-            title="Barley Yield by Year and Site",
-            tooltip=["yield", "site", "year"],
-            y_lim=None,
-            x_title=None,
-            y_title=None,
-            vertical=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
         )
-    elif display == "simple-horizontal":
-        return gr.BarPlot(
-            simple,
-            x="a",
-            y="b",
-            color=None,
-            group=None,
-            title="Simple Bar Plot with made up data",
-            tooltip=['a', 'b'],
-            y_lim=[20, 100],
-            x_title="Variable A",
-            y_title="Variable B",
-            vertical=False,
+
+    with gr.Row():
+        price_by_cuisine = gr.BarPlot(
+            food_rating_data,
+            x="cuisine",
+            y="price",
         )
-    elif display == "stacked-horizontal":
-        return gr.BarPlot(
-            barley,
-            x="variety",
-            y="yield",
-            color="site",
-            group=None,
-            title="Barley Yield Data",
-            tooltip=['variety', 'site'],
-            y_lim=None,
-            x_title=None,
-            y_title=None,
-            vertical=False,
+        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,
         )
-    elif display == "grouped-horizontal":
-        return gr.BarPlot(
-            barley.astype({"year": str}),
-            x="year",
-            y="yield",
-            color="year",
-            group="site",
-            title="Barley Yield by Year and Site",
-            group_title="",
-            tooltip=["yield", "site", "year"],
-            y_lim=None,
-            x_title=None,
-            y_title=None,
-            vertical=False
+        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"},
         )
 
 
-with gr.Blocks() as bar_plot:
-    display = gr.Dropdown(
-        choices=["simple", "stacked", "grouped", "simple-horizontal", "stacked-horizontal", "grouped-horizontal"],
-        value="simple",
-        label="Type of Bar Plot"
-    )
-    plot = gr.BarPlot(show_label=False)
-    display.change(bar_plot_fn, inputs=display, outputs=plot)
-    bar_plot.load(fn=bar_plot_fn, inputs=display, outputs=plot)
-
 if __name__ == "__main__":
-    bar_plot.launch()
+    bar_plots.launch()

demos/native_plots/data.py

@@ -0,0 +1,20 @@
+import pandas as pd
+from random import randint, choice, 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

@@ -1,82 +1,69 @@
 import gradio as gr
-from vega_datasets import data
+import numpy as np
+from data import temp_sensor_data, food_rating_data
 
-stocks = data.stocks()
-gapminder = data.gapminder()
-gapminder = gapminder.loc[
-    gapminder.country.isin(["Argentina", "Australia", "Afghanistan"])
-]
-climate = data.climate()
-seattle_weather = data.seattle_weather()
+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",
+    )
+    temp_by_time_location = gr.LinePlot(
+        temp_sensor_data,
+        x="time",
+        y="temperature",
+        color="location",
+    )
+
+    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 line_plot_fn(dataset):
-    if dataset == "stocks":
-        return gr.LinePlot(
-            stocks,
-            x="date",
-            y="price",
-            color="symbol",
-            x_lim=None,
-            y_lim=None,
-            stroke_dash=None,
-            tooltip=['date', 'price', 'symbol'],
-            overlay_point=False,
-            title="Stock Prices",
-            stroke_dash_legend_title=None,
-        )
-    elif dataset == "climate":
-        return gr.LinePlot(
-            climate,
-            x="DATE",
-            y="HLY-TEMP-NORMAL",
-            color=None,
-            x_lim=None,
-            y_lim=[250, 500],
-            stroke_dash=None,
-            tooltip=['DATE', 'HLY-TEMP-NORMAL'],
-            overlay_point=False,
-            title="Climate",
-            stroke_dash_legend_title=None,
-        )
-    elif dataset == "seattle_weather":
-        return gr.LinePlot(
-            seattle_weather,
-            x="date",
-            y="temp_min",
-            color=None,
-            x_lim=None,
-            y_lim=None,
-            stroke_dash=None,
-            tooltip=["weather", "date"],
-            overlay_point=True,
-            title="Seattle Weather",
-            stroke_dash_legend_title=None,
-        )
-    elif dataset == "gapminder":
-        return gr.LinePlot(
-            gapminder,
-            x="year",
-            y="life_expect",
-            color="country",
-            x_lim=[1950, 2010],
-            y_lim=None,
-            stroke_dash="cluster",
-            tooltip=['country', 'life_expect'],
-            overlay_point=False,
-            title="Life expectancy for countries",
-        )
 
+    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
+        )
 
-with gr.Blocks() as line_plot:
-    dataset = gr.Dropdown(
-        choices=["stocks", "climate", "seattle_weather", "gapminder"],
-        value="stocks",
+    price_by_cuisine = gr.LinePlot(
+        food_rating_data,
+        x="cuisine",
+        y="price",
     )
-    plot = gr.LinePlot()
-    dataset.change(line_plot_fn, inputs=dataset, outputs=plot)
-    line_plot.load(fn=line_plot_fn, inputs=dataset, outputs=plot)
+    with gr.Row():
+        price_by_rating = gr.LinePlot(
+            food_rating_data,
+            x="rating",
+            y="price",
+        )
+        price_by_rating_color = gr.LinePlot(
+            food_rating_data,
+            x="rating",
+            y="price",
+            color="cuisine",
+            color_map={"Italian": "red", "Mexican": "green", "Chinese": "blue"},
+        )
 
 
 if __name__ == "__main__":
-    line_plot.launch()
+    line_plots.launch()

demos/native_plots/run.ipynb

@@ -1 +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"]}, {"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/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_plot\n", "from line_plot_demo import line_plot\n", "from bar_plot_demo import bar_plot\n", "\n", "\n", "with gr.Blocks() as demo:\n", "    with gr.Tabs():\n", "        with gr.TabItem(\"Scatter Plot\"):\n", "            scatter_plot.render()\n", "        with gr.TabItem(\"Line Plot\"):\n", "            line_plot.render()\n", "        with gr.TabItem(\"Bar Plot\"):\n", "            bar_plot.render()\n", "\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}
+{"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"]}, {"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\n", "from line_plot_demo import line_plots\n", "from bar_plot_demo import bar_plots\n", "\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

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

demos/native_plots/scatter_plot_demo.py

@@ -1,46 +1,71 @@
 import gradio as gr
+import numpy as np
+from data import temp_sensor_data, food_rating_data
 
-from vega_datasets import data
-
-cars = data.cars()
-iris = data.iris()
-
-
-def scatter_plot_fn(dataset):
-    if dataset == "iris":
-        return gr.ScatterPlot(
-            value=iris,
-            x="petalWidth",
-            y="petalLength",
-            color=None,
-            title="Iris Dataset",
-            x_title="Petal Width",
-            y_title="Petal Length",
-            tooltip=["petalWidth", "petalLength", "species"],
-            caption="",
-            height=600,
-            width=600,
+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",
+    )
+    temp_by_time_location = gr.ScatterPlot(
+        temp_sensor_data,
+        x="time",
+        y="temperature",
+        color="location",
+    )
+
+    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",
+    )
+    with gr.Row():
+        price_by_rating = gr.ScatterPlot(
+            food_rating_data,
+            x="rating",
+            y="price",
+            color="wait",
+            show_actions_button=True,
         )
-    else:
-        return gr.ScatterPlot(
-            value=cars,
-            x="Horsepower",
-            y="Miles_per_Gallon",
-            color="Origin",
-            tooltip="Name",
-            title="Car Data",
-            y_title="Miles per Gallon",
-            caption="MPG vs Horsepower of various cars",
-            height=None,
-            width=None,
+        price_by_rating_color = gr.ScatterPlot(
+            food_rating_data,
+            x="rating",
+            y="price",
+            color="cuisine",
+            # color_map={"Italian": "red", "Mexican": "green", "Chinese": "blue"},
         )
 
 
-with gr.Blocks() as scatter_plot:
-    dataset = gr.Dropdown(choices=["cars", "iris"], value="cars")
-    plot = gr.ScatterPlot(show_label=False)
-    dataset.change(scatter_plot_fn, inputs=dataset, outputs=plot)
-    scatter_plot.load(fn=scatter_plot_fn, inputs=dataset, outputs=plot)
-
 if __name__ == "__main__":
-    scatter_plot.launch()
+    scatter_plots.launch()

requirements.txt

@@ -1,6 +1,6 @@
 
-gradio-client @ git+https://github.com/gradio-app/gradio@76200c11bd50edaaa08b7adcc28009499b3d30c2#subdirectory=client/python
-https://gradio-builds.s3.amazonaws.com/76200c11bd50edaaa08b7adcc28009499b3d30c2/gradio-4.38.1-py3-none-any.whl
+gradio-client @ git+https://github.com/gradio-app/gradio@4d99fb6c43199453f01a1b4fa9218ddce93c0db6#subdirectory=client/python
+https://gradio-builds.s3.amazonaws.com/4d99fb6c43199453f01a1b4fa9218ddce93c0db6/gradio-4.38.1-py3-none-any.whl
 pypistats==1.1.0
 plotly
 altair