Gradio

https://gradio.app/
Admin
Gradio is a Python library for quickly building and sharing web interfaces for machine learning...
Tokens:294,228
Snippets:2,202
Trust Score:9.8
Update:1 week ago
Show doc for...
Tokens:
Raw
### Launch Interface with share and auth

Source: https://gradio.app/docs/gradio/interface

Example usage of the launch method to start the Gradio interface with share=True and authentication credentials.

```python
import gradio as gr
def reverse(text):
    return text[::-1]
demo = gr.Interface(reverse, "text", "text")
demo.launch(share=True, auth=("username", "password"))
```

--------------------------------

### Install gradio_client, fastapi, and uvicorn

Source: https://gradio.app/guides/fastapi-app-with-the-gradio-client

Install the required Python libraries for the Acapellify web app: gradio_client, fastapi, and uvicorn. Run this command in your terminal before proceeding.

```bash
$ pip install gradio_client fastapi uvicorn
```

--------------------------------

### examples parameter type

Source: https://gradio.app/docs/gradio/interface

The examples parameter accepts a list of samples, a list of lists, a string path, or None.

```python
examples: list[Any] | list[list[Any]] | str | None
```

--------------------------------

### Install Gradio from main

Source: https://gradio.app/docs/gradio/blocks

Command to install the Gradio build from the main branch using a direct wheel URL. Note that setting share=True in launch() will not work with this build.

```bash
pip install https://gradio-builds.s3.amazonaws.com/ff0dfca072af1424d32d2acc43053915530366cb/gradio-6.29.1-py3-none-any.whl
```

--------------------------------

### Create a custom progress bar with gr.Progress

Source: https://gradio.app/guides/progress-bars

Add a `progress=gr.Progress()` parameter to your function to enable progress updates. Call `progress(0, desc="Starting")` to set the initial state, `progress(0.05)` to update progress with a float between 0 and 1, and use `progress.tqdm(word, desc="Reversing")` to track progress over an iterable. The example defines a `slowly_reverse` function that reverses a string with simulated delays and launches a Gradio interface.

```python
import gradio as gr
import time

def slowly_reverse(word, progress=gr.Progress()):
    progress(0, desc="Starting")
    time.sleep(1)
    progress(0.05)
    new_string = ""
    for letter in progress.tqdm(word, desc="Reversing"):
        time.sleep(0.25)
        new_string = letter + new_string  
    return new_string

demo = gr.Interface(slowly_reverse, gr.Text(), gr.Text(), api_name="predict")

demo.launch()

```

--------------------------------

### Enable GRADIO_RESET_EXAMPLES_CACHE

Source: https://gradio.app/guides/environment-variables

When set to True, Gradio deletes and recreates the examples cache directory at app startup instead of reusing existing cached examples.

```bash
export GRADIO_RESET_EXAMPLES_CACHE="True"
```

--------------------------------

### Blocks example with layout and events

Source: https://gradio.app/docs/gradio/blocks

Complete Blocks example showing layout with Markdown, Row, Textbox, and Button components, and an event handler that updates the output when the button is clicked.

```python
import gradio as gr
def update(name):
    return f"Welcome to Gradio, {name}!"

with gr.Blocks() as demo:
    gr.Markdown("Start typing below and then click **Run** to see the output.")
    with gr.Row():
        inp = gr.Textbox(placeholder="What is your name?")
        out = gr.Textbox()
    btn = gr.Button("Run")
    btn.click(fn=update, inputs=inp, outputs=out)

demo.launch()
```

--------------------------------

### Audio as input component example

Source: https://gradio.app/docs/gradio/audio

Example of using Audio as an input component. The function receives the audio value as a string filepath or a tuple of (sample rate, numpy array) depending on the 'type' parameter.

```python
    import gradio as gr

    def predict(
        value: str | tuple[int, np.ndarray] | None
    ):
        # process value from the Audio component
        return "prediction"

    interface = gr.Interface(predict, gr.Audio(), gr.Textbox())
    interface.launch()

```

--------------------------------

### queue example usage

Source: https://gradio.app/docs/gradio/interface

Example of using queue with max_size=20. The queue will store up to 20 events; if full, new events are not added and the user receives a message.

```python
demo = gr.Interface(image_generator, gr.Textbox(), gr.Image())
demo.queue(max_size=20)
demo.launch()
```

--------------------------------

### Start the development server with `gradio cc dev`

Source: https://gradio.app/guides/custom-components-in-five-minutes

Run this command from your component directory (or pass a path as the first argument) to start a development server. The console prints a 'Frontend Server (Go here):' URL, typically http://localhost:7861/, where you can view the demo app in hot reload mode.

```bash
gradio cc dev
```

--------------------------------

### Install requirements for RT-DETR object detection

Source: https://gradio.app/guides/object-detection-from-video

List of Python packages to install for the object detection guide. Requires opencv-python, torch, transformers>=4.43.0, and spaces.

```text
opencv-python
torch
transformers>=4.43.0
spaces
```

--------------------------------

### Queue example with gr.Blocks

Source: https://gradio.app/docs/gradio/blocks

Shows how to enable the queue on a Blocks demo, set a maximum size of 10, and launch the app. The button click triggers an image_generator function.

```python
with gr.Blocks() as demo:
    button = gr.Button(label="Generate Image")
    button.click(fn=image_generator, inputs=gr.Textbox(), outputs=gr.Image())
demo.queue(max_size=10)
demo.launch()
```

--------------------------------

### Install Gradio with pip

Source: https://gradio.app/guides

Install Gradio using pip. Requires Python 3.10 or higher. Recommended to install in a virtual environment.

```bash
pip install --upgrade gradio
```

--------------------------------

### Check ffmpeg installation

Source: https://gradio.app/guides/fastapi-app-with-the-gradio-client

Check if ffmpeg is already installed on your system. If the command fails, install ffmpeg following the provided instructions.

```bash
$ ffmpeg version
```

--------------------------------

### Install gradio-pdf with pip

Source: https://gradio.app/guides/pdf-component-example

Install the custom component package with pip so it can be used in any Gradio 4.0 app.

```bash
pip install gradio-pdf
```

--------------------------------

### Install Gradio with MCP add-on

Source: https://gradio.app/guides/building-chatgpt-apps-with-gradio

Install or upgrade Gradio with the MCP add-on. Requires gradio>=6.0.

```bash
pip install --upgrade gradio[mcp]
```

--------------------------------

### Launch Blocks with share and auth

Source: https://gradio.app/docs/gradio/blocks

Example of launching a Blocks demo with share=True to create a public link and auth to require username and password.

```python
import gradio as gr
def reverse(text):
    return text[::-1]
with gr.Blocks() as demo:
    button = gr.Button(value="Reverse")
    button.click(reverse, gr.Textbox(), gr.Textbox())
demo.launch(share=True, auth=("username", "password"))
```

--------------------------------

### Basic Interface usage example

Source: https://gradio.app/docs/gradio/interface

Creates a simple image classifier interface with an image input and label output, then launches the demo.

```python
import gradio as gr

def image_classifier(inp):
    return {'cat': 0.3, 'dog': 0.7}

demo = gr.Interface(fn=image_classifier, inputs="image", outputs="label")
demo.launch()
```

--------------------------------

### Group example usage

Source: https://gradio.app/docs/gradio/group

Example of using gr.Group to group two textboxes without padding or margin between them.

```python
with gr.Group():
    gr.Textbox(label="First")
    gr.Textbox(label="Last")
```

--------------------------------

### Gallery as output component example

Source: https://gradio.app/docs/gradio/gallery

Example of using Gallery as an output component. The predict function returns a list of images or videos, or a list of (media, caption) tuples. The example creates an Interface with Textbox as input and Gallery as output.

```python
    import gradio as gr

    def predict(text) -> list[GalleryMediaType | CaptionedGalleryMediaType] | None
        # process value to return to the Gallery component
        return value

    interface = gr.Interface(predict, gr.Textbox(), gr.Gallery())
    interface.launch()

```

--------------------------------

### gradio.Interface.launch

Source: https://gradio.app/docs/gradio/interface

Launches a simple web server that serves the demo. Can also be used to create a public link used by anyone to access the demo from their browser by setting share=True.

```APIDOC
## gradio.Interface.launch

### Description
Launches a simple web server that serves the demo. Can also be used to create a public link used by anyone to access the demo from their browser by setting share=True.

### Method
launch

### Endpoint
N/A (SDK method)

### Parameters
#### Query Parameters
- **inline** (bool | None) - Optional - Whether to display in the gradio app inline in an iframe. Defaults to True in python notebooks; False otherwise.
- **inbrowser** (bool) - Optional - Whether to automatically launch the gradio app in a new tab on the default browser. Defaults to False.
- **share** (bool | None) - Optional - Whether to create a public link. (Exact description not provided in source)

### Request Example
```python
import gradio as gr

def reverse(text):
    return text[::-1]

demo = gr.Interface(reverse, "text", "text")
demo.launch(share=True, auth=("username", "password"))
```

### Response
#### Success Response
No explicit response schema provided in source.

```

--------------------------------

### Implement process_example method

Source: https://gradio.app/guides/backend

Converts an example input value to the display value. If not provided, postprocess is used. For SimpleDropdown, choices is a list of (display_name, value) tuples; returns None if value not found.

```python
def process_example(self, input_data):
    return next((c[0] for c in self.choices if c[1] == input_data), None)
```

--------------------------------

### Create a Gradio Interface demo

Source: https://gradio.app/guides

Defines a greet function and wraps it with gr.Interface. Uses text and slider inputs, text output, and api_name='predict'. Launch opens the demo at http://localhost:7860 when run from a file.

```python
import gradio as gr

def greet(name, intensity):
    return "Hello, " + name + "!" * int(intensity)

demo = gr.Interface(
    fn=greet,
    inputs=["text", "slider"],
    outputs=["text"],
    api_name="predict"
)

demo.launch()
```

--------------------------------

### log.csv example for directory-based examples

Source: https://gradio.app/guides/more-on-examples

CSV file used when the Interface has multiple inputs and examples are loaded from a directory. The first row lists the input component names, and each subsequent row provides a data sample with values in the same order as the prediction function expects them.

```csv
num,operation,num2
5,"add",3
4,"divide",2
5,"multiply",3

```

--------------------------------

### Gallery as input component example

Source: https://gradio.app/docs/gradio/gallery

Example of using Gallery as an input component. The predict function receives a list of (media, caption) tuples, where media can be a file path, numpy array, or PIL.Image. The example creates an Interface with Gallery as input and Textbox as output.

```python
    import gradio as gr

    def predict(
        value: list[tuple[str, str | None]] | list[tuple[PIL.Image.Image, str | None]] | list[tuple[np.ndarray, str | None]] | None
    ):
        # process value from the Gallery component
        return "prediction"

    interface = gr.Interface(predict, gr.Gallery(), gr.Textbox())
    interface.launch()

```

--------------------------------

### Build custom component with gradio cc build

Source: https://gradio.app/guides/custom-components-in-five-minutes

Run from the component directory to create a tar.gz and .whl file in a dist/ subdirectory. Also generates documentation as an interactive space and a static README.md unless --no-generate-docs is passed.

```bash
gradio cc build
```

--------------------------------

### Serve additional files with demo.launch(file_directories)

Source: https://gradio.app/changelog

Use this snippet to serve additional files from specified directories when launching a Gradio interface. The `file_directories` parameter accepts a list of directory paths, and the example shows a single path.

```python
demo = gr.Interface(...)
demo.launch(
  file_directories=["/var/lib/demo/path/to/resources"]
)
```

--------------------------------

### Install required packages

Source: https://gradio.app/guides/building-an-mcp-client-with-gradio

Installs the required Python packages for the MCP client and server: Gradio, Anthropic SDK, and the MCP library.

```bash
pip install gradio anthropic mcp
```

--------------------------------

### Launch demo with gr.Image input and output

Source: https://gradio.app/docs/gradio/image

Example of a simple Gradio Interface that takes an image filepath as input and returns an image. Note that for animated GIFs, setting type="filepath" is necessary to avoid using only the first frame.

```python
import gradio as gr

demo = gr.Interface(
    fn=lambda x:x, 
    inputs=gr.Image(type="filepath"), 
    outputs=gr.Image()
)
    
demo.launch()
```

--------------------------------

### Create a FastAPI app with upload and gallery routes

Source: https://gradio.app/guides/fastapi-app-with-the-gradio-client

Basic FastAPI app with two routes: `/` returns an HTML template displaying a gallery of uploaded videos, and `/uploadvideo/` accepts a POST request with an `UploadFile`, processes the video via `process_video()`, and stores the result in an in-memory list. This is a simple example; production apps need additional logic for file storage, authentication, and security.

```python
import os
from fastapi import FastAPI, File, UploadFile, Request
from fastapi.responses import HTMLResponse, RedirectResponse
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates

app = FastAPI()
os.makedirs("static", exist_ok=True)
app.mount("/static", StaticFiles(directory="static"), name="static")
templates = Jinja2Templates(directory="templates")

videos = []

@app.get("/", response_class=HTMLResponse)
async def home(request: Request):
    return templates.TemplateResponse(
        "home.html", {"request": request, "videos": videos})

@app.post("/uploadvideo/")
async def upload_video(video: UploadFile = File(...)):
    video_path = video.filename
    with open(video_path, "wb+") as fp:
        fp.write(video.file.read())

    new_video = process_video(video.filename)
    videos.append(new_video)
    return RedirectResponse(url='/', status_code=303)
```
Tokens:
Raw