Commit 3: Add 19 file(s)

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

demos/stream_audio_out/run.ipynb

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

demos/stream_audio_out/run.py

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

demos/stream_frames/requirements.txt

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

demos/stream_frames/run.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", "    api_name=\"predict\",\n", ")\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

demos/stream_frames/run.py

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

demos/stt_or_tts/run.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", "    api_name=\"predict\"\n", ")\n", "\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

demos/video_component/run.py

@@ -0,0 +1,19 @@
+import gradio as gr
+# get_video() returns the file path to sample videos included with Gradio
+from gradio.media import get_video
+
+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,
+    api_name="predict"
+)
+
+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", "    api_name=\"predict\"\n", ")\n", "\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

demos/zip_files/run.py

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

requirements.txt

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