Streamlit, Taipy, Dash et Gradio : Créez des applications web interactives en Python

En Python, nous créons des scripts pour analyser des données, automatiser des tâches, manipuler des fichiers, etc.

J'ai récemment écrit un article sur Streamlit dans lequel on se posait la question :

Comment faciliter le partage d'un script avec des collègues non-développeurs, sous la forme d'une interface simple et intuitive ?

Streamlit est une excellente réponse à cette question, mais ce n'est pas la seule. Il existe d'autres alternatives comme Taipy, Dash et Gradio.

Dans cet article, nous allons passer en revue ces différentes solutions.

Des applications web en pur Python

Nous ne parlons pas ici de frameworks web comme Django ou Flask qui sont conçus pour développer des applications web complexes de A à Z.

Les outils que nous allons évoquer proposent une approche différente. Il s'agit de bibliothèques qui vous permettent de construire une interface utilisateur uniquement en Python !

Vous écrivez votre logique ou récupérez un script déjà existant, puis ajoutez quelques lignes de code pour créer des éléments interactifs comme des boutons, champs de saisie, curseurs, graphiques, etc. C'est la bibliothèque qui se charge de générer le code HTML/CSS/JavaScript.

Bien que ces bibliothèques permettent de créer toutes sortes d'applications, leur premier objectif est de donner aux data scientists un outil pour interfacer leurs scripts, présenter leurs données et créer des visuels interactifs.

Pour ma part, j'ai déjà utilisé Streamlit hors de ce cadre pour développer des applications dans le commerce.

Quelques bibliothèques

Dans cette partie, nous allons évoquer quatre bibliothèques populaires :

Streamlit

Page d'accueil

Lancé en 2019, Streamlit permet la transformation d'un script en application via quelques fonctions. Dès qu'un utilisateur interagit avec un slider, un bouton, un input, le script est ré-exécuté du début à la fin, permettant d'obtenir l'état le plus récent de l'application, sans complexité. Nul besoin d'utiliser des callbacks ou des listeners.

Si tu sais faire un script Python, tu sais faire du Streamlit !

En effet, il n'y a pas à se soucier de la synchronisation des éléments, et il est simple de tester et déboguer son application au fur et à mesure.

Même pour les calculs lourds, Streamlit a prévu des fonctions décoratrices pour améliorer l'efficacité de ton application.

Voici un exemple de code :

import streamlit as st
import pandas as pd
import numpy as np

st.title("Mon App Streamlit Super Simple")

# Widget pour choisir le nombre de points
nombre_points = st.slider("Choisissez le nombre de points", 10, 100, 50)

# Génération de données
data = pd.DataFrame({
    'x': np.random.randn(nombre_points),
    'y': np.random.randn(nombre_points),
})

# Affichage d'un graphique
st.line_chart(data)


                PYTHON
            

Exemple Streamlit

Taipy

Page d'accueil de Taipy

Arrivé plus récemment, Taipy permet non seulement de créer des interfaces graphiques, mais aussi de gérer des pipelines de tâches complexes.

Taipy est composé de deux parties :

Taipy Core, pour les pipelines
Taipy GUI, pour l'interface qui peut se connecter à Taipy Core

Il y a donc une séparation entre la logique et l'interface, ce qui est à la fois puissant et efficace, mais nécessite une courbe d'apprentissage un peu plus importante que Streamlit. En réalité, les philosophies sont différentes : Streamlit privilégie la simplicité et la rapidité, tandis que Taipy offre plus de contrôle architectural pour des applications plus complexes.

Taipy se démarque par la gestion des scénarios et sa logique de traitement de données complexes en arrière-plan.

Exemple de code minimaliste avec Taipy GUI :

from taipy.gui import Gui

valeur = 10
page = """
# Bienvenue sur mon app Taipy

Valeur du curseur : <|{valeur}|>
<|{valeur}|slider|>
"""

Gui(page).run()


                PYTHON
            

Exemple Taipy GUI

Dash

Page d'accueil de Dash

Dash a été développé par les créateurs de Plotly en 2017. Il propose une approche web-dev via son système de callbacks. Sur le principe, vous définissez des fonctions qui se déclenchent lorsque l'utilisateur interagit avec un composant (Input). Ensuite, la fonction retourne des valeurs pour mettre à jour un ou plusieurs autres composants (Output).

Dash est idéal pour les applications nécessitant une forte personnalisation et un contrôle fin des interactions.

Vous pouvez voir dans l'exemple ci-dessous le décorateur callback avec les objets Output et Input :

from dash import Dash, html, dcc, callback, Output, Input
import plotly.express as px
import pandas as pd

df = pd.read_csv('https://raw.githubusercontent.com/plotly/datasets/master/gapminder_unfiltered.csv')

app = Dash()


app.layout = [
    html.H1(children='Title of Dash App', style={'textAlign':'center'}),
    dcc.Dropdown(df.country.unique(), 'Canada', id='dropdown-selection'),
    dcc.Graph(id='graph-content')
]

@callback(
    Output('graph-content', 'figure'),
    Input('dropdown-selection', 'value')
)
def update_graph(value):
    dff = df[df.country==value]
    return px.line(dff, x='year', y='pop')

if __name__ == '__main__':
    app.run(debug=True)


                PYTHON
            

Exemple de la documentation

Gradio

Page d'accueil de Gradio

Gradio permet de créer des démonstrations web facilement en transformant des fonctions Python en une interface interactive, qu'il s'agisse de Machine Learning ou non. Si je le précise, c'est parce qu'à l'origine Gradio a été créé pour interfacer des modèles de Machine Learning.

De plus, Gradio supporte différents types de données : images, texte, audio, fichier, etc.

Gradio demande trois choses : la fonction à appeler, le composant d'entrée et le composant de sortie. Facile non ?!

Car en arrière-plan Gradio se charge de générer l'interface pour vous.

Voici une petite démonstration qui combine Gradio et Mistral AI 🇫🇷 :

L'input, c'est le texte que l'utilisateur tape
La fonction chat_mistral va prendre le message
L'output, c'est la valeur retournée par notre fonction

import gradio as gr
from mistralai import Mistral
import environ


env = environ.Env()
environ.Env.read_env()


mistral_api = env("API")
model = "mistral-large-latest"

client = Mistral(api_key=mistral_api)


def chat_mistral(message, _):
    response = client.chat.complete(
        model=model,
        messages=[
            {
                "role": "user",
                "content": message,
            }
        ],
    )
    return response.choices[0].message.content


chat = gr.ChatInterface(
    fn=chat_mistral,
    title="Mon French Mistral Chatbot",
    description="Tu tchat en mode Made in France",
)


if __name__ == "__main__":
    chat.launch()


                PYTHON
            

Démonstration du code ci-dessus

Lequel choisir ?

Vous vous en doutez, c'est comme si on devait répondre à la question : Django ou Flask ?

Mais vous avez pu le remarquer, toutes les bibliothèques que nous avons présentées répondent à des besoins assez particuliers.

Tout dépend donc de votre besoin et de vos habitudes.

Pour ma part, j'ai longtemps pris l'habitude d'utiliser Streamlit dans le commerce, mais pour m'être initié à Gradio je le trouve vraiment parfait pour le côté Python + IA.

L'avantage de ces différents outils, c'est qu'ils permettent de créer des interfaces très rapidement !