Metadata-Version: 2.1
Name: gradio
Version: 3.1.2
Summary: Python library for easily interacting with trained machine learning models
Home-page: https://github.com/gradio-app/gradio
Author: Abubakar Abid, Ali Abid, Ali Abdalla, Dawood Khan, Ahsen Khaliq, Pete Allen, Ömer Faruk Özdemir
Author-email: team@gradio.app
License: Apache License 2.0
Keywords: machine learning,visualization,reproducibility
Platform: UNKNOWN
Requires-Python: >=3.7
Description-Content-Type: text/markdown
License-File: LICENSE

<!-- DO NOT EDIT THIS FILE DIRECTLY. INSTEAD PLEASE EDIT: "readme_template.md" or 
    "guides/getting_started.md", AND THEN RUN: "python render_readme.py" --> 
<p align="center">
  <a href="https://gradio.app"><img src="readme_files/gradio.svg" alt="gradio" width=300></a> 
</p>
<p align="center">
    <em>Build & share delightful machine learning apps easily</em>
<p align="center">
<a href="https://circleci.com/gh/gradio-app/gradio" target="_blank">
    <img src="https://circleci.com/gh/gradio-app/gradio.svg?style=svg" alt="circleci">
</a>
<a href="https://badge.fury.io/py/gradio" target="_blank">
    <img src="https://badge.fury.io/py/gradio.svg" alt="pypi">
</a>
<a href="https://codecov.io/gh/gradio-app/gradio/branch/master/graph/badge.svg?token=NNVPX9KEGS" target="_blank">
    <img src="https://codecov.io/gh/gradio-app/gradio/branch/master/graph/badge.svg?token=NNVPX9KEGS" alt="Codecov">
</a>
<a href="https://pypi.org/project/gradio/" target="_blank">
    <img src="https://img.shields.io/pypi/dm/gradio" alt="pypi">
</a>
<a href="https://twitter.com/gradio " target="_blank">
    <img src="https://img.shields.io/twitter/follow/gradio.svg?style=social&label=Follow" alt="twitter">
</a>
</p>

# Gradio: Build Machine Learning Web Apps — in Python

Gradio is an open-source Python library that is used to build machine learning and data science demos and web applications.

With Gradio, you can quickly create a beautiful user interface around your machine learning models or data science workflow and let people "try it out" by dragging-and-dropping in their own images,
pasting text, recording their own voice, and interacting with your demo, all through the browser.

![Interface montage](readme_files/header-image.jpg)

Gradio is useful for:

* **Demoing** your machine learning models for clients / collaborators / users / students

* **Deploying** your models quickly with automatic shareable links and getting feedback on model performance

* **Debugging** your model interactively during development using built-in manipulation and interpretation tools

**You can find an interactive version of the following Getting Started at [https://gradio.app/getting_started](https://gradio.app/getting_started).**

# Quickstart

Docs: examples

**Prerequisite**: Gradio requires Python 3.7 or above, that's it! 

## What does Gradio Do?

One of the *best ways to share* your machine learning model, API, or data science workflow with others is to create an **interactive app** that allows your users or colleagues to try out the demo in their browsers. 

Gradio allows you to **build demos and share them, all in Python.** And usually in just a few lines of code! So let's get started. 

## Hello, World

To get Gradio running with a simple "Hello, World" example, follow these three steps:

<span>1.</span> Install Gradio from pip. Note, the minimal supported Python version is 3.7.

```bash
pip install gradio
```

<span>2.</span> Run the code below as a Python script or in a Python notebook (or in a  [colab notebook](https://colab.research.google.com/drive/18ODkJvyxHutTN0P5APWyGFO_xwNcgHDZ?usp=sharing)).

```python
import gradio as gr

def greet(name):
    return "Hello " + name + "!"

demo = gr.Interface(fn=greet, inputs="text", outputs="text")
demo.launch()

```

<span>3.</span> The demo below will appear automatically within the Python notebook, or pop in a browser on  [http://localhost:7860](http://localhost:7860/)  if running from a script.

![hello_world interface](https://raw.githubusercontent.com/gradio-app/gradio/main/demo/hello_world/screenshot.gif)

## The `Interface` Class

You'll notice that in order to make the demo, we created a `gradio.Interface`. This `Interface` class can wrap any Python function with a user interface. In the example above, we saw a simple text-based function. But the function could be anything from music generator to a tax calculator to the prediction function of a pretrained machine learning model.

The core `Interface` class is initialized with three required parameters:

-   `fn`: the function to wrap a UI around
-   `inputs`: which component(s) to use for the input, e.g. `"text"` or `"image"` or `"audio"` 
-   `outputs`: which component(s) to use for the output, e.g. `"text"` or `"image"` `"label"`

Let's take a closer look at these Components used to provide input and output.

## Components

### Components Attributes

We saw some simple Textbox components in the previous example. But what if you want to change how the UI components look or behave?

Let's say you want to customize the input text field - for example, you wanted it to be larger and have a text placeholder. If we use the actual class for  `Textbox`  instead of using the string shortcut, you have access to much more customizability through component attributes.

```python
import gradio as gr

def greet(name):
    return "Hello " + name + "!"

demo = gr.Interface(
    fn=greet,
    inputs=gr.Textbox(lines=2, placeholder="Name Here..."),
    outputs="text",
)
demo.launch()

```
![hello_world_2 interface](https://raw.githubusercontent.com/gradio-app/gradio/main/demo/hello_world_2/screenshot.gif)

### Multiple Input and Output Components

Let's say you had a more complex function, with multiple inputs and outputs. In the example below, we define a function that takes a string, boolean, and number, and returns a string and number. Take a look how you pass a list of input and output components.

```python
import gradio as gr

def greet(name, is_morning, temperature):
    salutation = "Good morning" if is_morning else "Good evening"
    greeting = f"{salutation} {name}. It is {temperature} degrees today"
    celsius = (temperature - 32) * 5 / 9
    return greeting, round(celsius, 2)

demo = gr.Interface(
    fn=greet,
    inputs=["text", "checkbox", gr.Slider(0, 100)],
    outputs=["text", "number"],
)
demo.launch()

```
![hello_world_3 interface](https://raw.githubusercontent.com/gradio-app/gradio/main/demo/hello_world_3/screenshot.gif)

You simply wrap the components in a list. Each component in the `inputs` list corresponds to one of the parameters of the function, in order. Each component in the `outputs` list corresponds to one of the values returned by the function, again in order. 

### An Image Example

Gradio supports many types of Components, such as `Image`, `DataFrame`, `Video`, or `Label`. Let's try an image-to-image function to get a feel for these! 

```python
import numpy as np
import gradio as gr

def sepia(input_img):
    sepia_filter = np.array([
        [0.393, 0.769, 0.189], 
        [0.349, 0.686, 0.168], 
        [0.272, 0.534, 0.131]
    ])
    sepia_img = input_img.dot(sepia_filter.T)
    sepia_img /= sepia_img.max()
    return sepia_img

demo = gr.Interface(sepia, gr.Image(shape=(200, 200)), "image")
demo.launch()

```
![sepia_filter interface](https://raw.githubusercontent.com/gradio-app/gradio/main/demo/sepia_filter/screenshot.gif)

When using the  `Image` Component as input, your function will receive a numpy array with the shape  `(width, height, 3)`, where the last dimension represents the RGB values. We'll return an image as well in the form of a numpy array. You can learn the Python datatype used by each Component in the [Docs](https://gradio.app/docs). 

You can also set the datatype used by the Component with the `type=` keyword argument. For example, if you wanted your function to take a filepath to an image instead of a numpy array, the input `Image` component could be written as

```python
gr.Image(type='filepath', shape=...)
```

Also note that our  input `Image` Component comes with an 'edit' button, which allows for cropping and zooming into images. Manipulating images in this way can help reveal biases or hidden flaws in a machine learning model!

Read more about the many Components and how to use them in the [Docs](https://gradio.app/docs).

## Blocks: More Flexibility and Control

Gradio offers two classes to build apps: 

(1) **Interface**, a high level abstraction for creating demos (that we've been discussing so far), and 

(2) **Blocks**, a low-level API for designing web apps with more flexible layouts and data flows. Blocks allows you to do things like: feature multiple data flows and demos, control where components appear on the page, handle complex data flows (e.g. outputs can serve as inputs to other functions), and update properties/visibility of components based on user interaction -- still all in Python. If this customizability is what you need, try `Blocks` instead! 

### Hello, Blocks

Let's take a look at a simple example. Note how the API here differs from `Interface`.

```python
import gradio as gr

def greet(name):
    return "Hello " + name + "!"

with gr.Blocks() as demo:
    name = gr.Textbox(label="Name")
    output = gr.Textbox(label="Output Box")
    greet_btn = gr.Button("Greet")
    greet_btn.click(fn=greet, inputs=name, outputs=output)

demo.launch()
```
![hello_blocks interface](https://raw.githubusercontent.com/gradio-app/gradio/main/demo/hello_blocks/screenshot.gif)

A couple things to note:

- a `Blocks` is created with a `with` clause, and any Component created inside this clause is automatically added to the app.
- Components appear vertically in the app in the order they are created. (Later we will cover customizing layouts!)
- a `Button` was created, and then a `click` event-listener was added to this button. The API for this should look familiar! Like an `Interface`, the `click` method takes (1) a python function, (2) input components, and (3) output components. 

### More Complexity

Here's an app to give you a taste of what's possible with Blocks.

```python
import numpy as np
import gradio as gr

def flip_text(x):
    return x[::-1]

def flip_image(x):
    return np.fliplr(x)

with gr.Blocks() as demo:
    gr.Markdown("Flip text or image files using this demo.")
    with gr.Tabs():
        with gr.TabItem("Flip Text"):
            text_input = gr.Textbox()
            text_output = gr.Textbox()
            text_button = gr.Button("Flip")
        with gr.TabItem("Flip Image"):
            with gr.Row():
                image_input = gr.Image()
                image_output = gr.Image()
            image_button = gr.Button("Flip")
    
    text_button.click(flip_text, inputs=text_input, outputs=text_output)
    image_button.click(flip_image, inputs=image_input, outputs=image_output)
    
demo.launch()
```
![blocks_flipper interface](https://raw.githubusercontent.com/gradio-app/gradio/main/demo/blocks_flipper/screenshot.gif)

A lot more going on here! We'll cover how to create complex `Blocks` apps like this in the [Building with Blocks](/building_with_blocks) section of the guides. 

Congrats, you're now familiar with the basics of Gradio 🥳. Onto the [next guide](https://gradio.app/key_features) - or skip around the curriculum if you wish!

## System Requirements:

- Python 3.7+

## Open Source Stack

Gradio is built with many wonderful open-source libraries, please support them as well!
<p>
<a href="https://hf.co/"><img src="readme_files/huggingface_mini.svg" alt="huggingface" height=40></a>
<a href="https://www.python.org/"><img src="readme_files/python.svg" alt="python" height=40></a>
<a href="https://fastapi.tiangolo.com/"><img src="readme_files/fastapi.svg" alt="fastapi" height=40></a>
<a href="https://github.com/encode/"><img src="readme_files/encode.svg" alt="encode" height=40></a>
<a href="https://svelte.dev"><img src="readme_files/svelte.svg" alt="svelte" height=40></a>
<a href="https://vitejs.dev/"><img src="readme_files/vite.svg" alt="vite" height=40></a>
<a href="https://pnpm.io/"><img src="readme_files/pnpm.svg" alt="pnpm" height=40></a>
<a href="https://tailwindcss.com/"><img src="readme_files/tailwind.svg" alt="tailwind" height=40></a>
</p>

## License:

Gradio is licensed under the Apache License 2.0

## See more:

You can find many more examples as well as more info on usage on our website: https://gradio.app

See, also, the accompanying paper: ["Gradio: Hassle-Free Sharing and Testing of ML Models in the Wild"](https://arxiv.org/pdf/1906.02569.pdf), *ICML HILL 2019*, and please use the citation below.

```
@article{abid2019gradio,
title={Gradio: Hassle-Free Sharing and Testing of ML Models in the Wild},
author={Abid, Abubakar and Abdalla, Ali and Abid, Ali and Khan, Dawood and Alfozan, Abdulrahman and Zou, James},
journal={arXiv preprint arXiv:1906.02569},
year={2019}
}
```


