Seraplot - Bien plus qu'une bibliothèque de graphiques

« Tout tracer. Tout entraîner. Partout déployer. »

SeraPlot est une boîte à outils data complète écrite en Rust. Le même moteur propulse vos visualisations, votre machine learning, et la façon dont vous livrez les résultats à vos collègues.

Une seule librairie remplace : matplotlib + plotly + dash + streamlit + seaborn + une partie de scikit-learn — avec un seul pip install et zéro dépendance d'exécution.

Même graphique — trois bibliothèques

import seraplot as sp
sp.bar("Chiffre d'affaires par produit", labels, values).save("chart.html")

import plotly.express as px
fig = px.bar(x=labels, y=values, title="Chiffre d'affaires par produit")
fig.update_layout(template="plotly_white")
fig.write_html("chart.html")

import matplotlib.pyplot as plt
fig, ax = plt.subplots(figsize=(9, 5))
ax.bar(labels, values, color="#6366f1")
ax.set_title("Chiffre d'affaires par produit")
ax.set_ylabel("Chiffre d'affaires")
plt.tight_layout()
plt.savefig("chart.png")

Pourquoi Seraplot ?

Comme vous l’aurez compris en arrivant jusqu’ici, Seraplot est un outil qui a pour objectif d’être extrêmement personnalisable, mais aussi beaucoup plus rapide et moins gourmand que ce qui existe déjà, en plus de proposer tout un panel d’aides, comme l’extension Seraplot dans VSCode, qui vous permettra de générer des plots ou des méthodes ML très rapidement et en live, entre chaque sauvegarde de vos scripts.

En plus de cela, Seraplot se voit distribué dans différents langages comme : JS/TS, C (C# & C++), Java, Rust, Python, R & Scala. L’objectif étant vraiment d’être ultra accessible : d’un langage à un autre, les commandes restent les mêmes pour plus de simplicité.

Pour résumer, Seraplot est un outil beaucoup plus pratique de ce qui existe déjà et complétement indépendant, en plus de compilé différente fonctionnalitée. En autre il permet la génération de plots 2D & 3D, mais aussi qui tend à proposer des méthodes liées au ML, que vous pourrez retrouver au cours de votre documentation. D’autres surprises vous attendent, que ce soit la possibilité de choisir différents thèmes, ou bien le système de chunks en cas de crash pour reprendre au point d’erreur, ou encore pour n'en citer que un dernier, le fait d’avoir différents alias pour utiliser une même méthode (ex : sp.build_bar_chart / sp.bar_chart / sp.bar / sp.bars).

1 000 graphiques. Mesurés.

Même code, mêmes données aléatoires, même machine. Sortie HTML complète chronométrée.

import seraplot as sp
categories = ["Électronique", "Vêtements", "Alimentation", "Livres", "Sport", "Jouets", "Santé", "Auto"]
data = [...]
for i in range(1000):
    sp.bar(f"Rapport #{i+1}", categories, data[i]).html

import plotly.graph_objects as go
categories = ["Électronique", "Vêtements", "Alimentation", "Livres", "Sport", "Jouets", "Santé", "Auto"]
data = [...]
for i in range(1000):
    fig = go.Figure(data=[go.Bar(x=categories, y=data[i])])
    fig.update_layout(title=f"Rapport #{i+1}", template="plotly_dark")
    fig.to_html(full_html=True, include_plotlyjs="cdn")

import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
categories = ["Électronique", "Vêtements", "Alimentation", "Livres", "Sport", "Jouets", "Santé", "Auto"]
data = [...]
for i in range(1000):
    fig, ax = plt.subplots(figsize=(9, 5))
    ax.bar(categories, data[i])
    ax.set_title(f"Rapport #{i+1}")
    fig.savefig(f"chart_{i}.png")
    plt.close()

Vitesse du moteur de rendu

Benchmark : dataset Diabetes (n=768, 40 itérations). Temps de rendu Rust — création de l'objet graphique, pas la sérialisation HTML complète.

Toutes les valeurs en µs.

Taille des fichiers de sortie

Plotly embarque tout son bundle JavaScript dans chaque fichier HTML. SeraPlot n'inclut que le JS nécessaire au type de graphique spécifique.

Matplotlib produit du PNG/SVG/PDF (50–500 Ko) — pas du HTML interactif.

Ce qu'est réellement SeraPlot

SeraPlot n'est pas un wrapper autour de Plotly, Chart.js ou D3.

C'est un moteur de rendu natif Rust qui génère du HTML + JS minimal par graphique. chaque chart reçoit soit js dédiée. Rien d'autre n'est embarqué.

C'est pour ça que la sortie fait 20 Ko au lieu de 4,7 Mo.

Migration en une ligne

import seraplot.matplotlib as plt

Tout le reste reste identique. plt.bar(), plt.scatter(), plt.hist(), plt.show(), plt.savefig() — inchangés.

Déployer depuis une API

from fastapi import FastAPI
import seraplot as sp
app = FastAPI()
@app.get("/chart")
def revenue_chart():
    return sp.bar("Chiffre d'affaires", labels, values).html

from fastapi import FastAPI
from fastapi.responses import HTMLResponse
import plotly.express as px
app = FastAPI()
@app.get("/chart", response_class=HTMLResponse)
def revenue_chart():
    fig = px.bar(x=labels, y=values, title="Chiffre d'affaires")
    return fig.to_html(full_html=True)

from fastapi import FastAPI
from fastapi.responses import FileResponse
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import tempfile
app = FastAPI()
@app.get("/chart")
def revenue_chart():
    fig, ax = plt.subplots(figsize=(9, 5))
    ax.bar(labels, values)
    ax.set_title("Chiffre d'affaires")
    path = tempfile.mktemp(suffix=".png")
    plt.savefig(path)
    plt.close()
    return FileResponse(path, media_type="image/png")

Plotly retourne 4,7 Mo par requête. Matplotlib nécessite des I/O disque et retourne un PNG statique. SeraPlot retourne 21 Ko de HTML interactif directement depuis la RAM.

Tout ce que SeraPlot fait

• 57 types de graphiques — chaque graphique 2D a une variante 3D WebGL
• API matplotlib drop-in — import seraplot.matplotlib as plt
• Pandas & NumPy natifs — passez les DataFrames directement
• 7 thèmes intégrés — dark, light, scientific, apple, notion, minimal, neon
• Configuration globale — sp.config() définit la police, le zoom, le réticule, l'animation pour tous les graphiques
• Zéro dépendance — moteur de rendu Rust pur
• Fichiers 200× plus petits — pas de runtime JS embarqué
• Multi-langage — Python, JavaScript/TypeScript (npm), Rust, R, Scala, C#, C++, Java
• DBSCAN jusqu'à 600× plus rapide que scikit-learn
• Machine learning natif — Plusieurs methods ml, sont déjà existante dans le framework
• Fonctionne partout — Python ≥ 3.8, tout OS

Navigation

• Installation — pip install seraplot
• Démarrage rapide — premier graphique en 3 lignes
• Méthodes des graphiques — toutes les méthodes universelles Chart
• Graphiques 2D — 33 types
• Graphiques 3D — 17 types, rendu GPU WebGL
• Machine Learning — DBSCAN jusqu'à 600× plus rapide que scikit-learn
• Référence API — index complet des fonctions

Prérequis

• Python 3.8+
• pip 21+

SeraPlot se distribue sous forme d'extension Rust compilée (.pyd / .so) incluse dans le wheel. Aucun compilateur n'est requis côté utilisateur — le binaire est pré-compilé pour chaque plateforme.

pip

pip install seraplot

pip install seraplot==2.3.61

pip install --upgrade seraplot

uv

uv est un gestionnaire de paquets Python rapide écrit en Rust.

uv add seraplot

conda

conda install -c conda-forge seraplot

Ou dans votre environment.yml :

dependencies:
  - pip:
    - seraplot

Pourquoi l'installation est aussi simple

SeraPlot n'a aucune dépendance Python requise. L'extension Rust est entièrement autonome — le HTML embarque son propre JavaScript sans rien charger depuis un CDN. Concrètement :

• les graphiques fonctionnent hors ligne, en environnement isolé, par e-mail, en impression PDF
• aucun conflit de version avec numpy, pandas ou scipy
• wheels disponibles pour Windows, Linux et macOS — aucune compilation nécessaire

Pour comparaison, pip install plotly télécharge ~15 Mo. pip install seraplot télécharge ~2 Mo.

Votre premier graphique

import seraplot as sp
chart = sp.build_bar_chart(
    "Ventes par région",
    labels=["Nord", "Sud", "Est", "Ouest"],
    values=[120.0, 85.0, 200.0, 140.0],
)

const sp = require('seraplot');
const chart = sp.build_bar_chart("Ventes par région", ["Nord", "Sud", "Est", "Ouest"], {
    values: [120.0, 85.0, 200.0, 140.0],
});

import * as sp from 'seraplot';
const chart = sp.build_bar_chart("Ventes par région", ["Nord", "Sud", "Est", "Ouest"], {
    values: [120.0, 85.0, 200.0, 140.0],
});

Dans Jupyter, le graphique s'affiche automatiquement.

Enregistrer en HTML

chart.save(nom_du_plot.html)

chart.save(nom_du_plot.html);

chart.save(nom_du_plot.html);

Chaque fonction SeraPlot retourne un objet Chart — un wrapper léger autour d'une chaîne HTML complète et autonome.

Propriétés

chart = sp.build_bar_chart("Titre", labels=["A", "B"], values=[1.0, 2.0])
print(len(chart.html))    # typiquement 20 000 à 90 000 octets

Affichage automatique dans Jupyter

Les graphiques s'affichent automatiquement à la fin d'une cellule Jupyter. Aucun appel à display() n'est nécessaire.

Pour désactiver :

sp.set_auto_display(False)

Affichage manuel

Comme dit au précédemment, vous n'avez aucunement besoin de rien, juste de crée votre chart, Seraplot à une fonction native d'affichage

Export vers fichier

chart.save("sortie.html")
# ou
with open("sortie.html", "w", encoding="utf-8") as f:
    f.write(chart.html)

Chaînage de méthodes

chart = (
    sp.build_bar_chart("Ventes", labels, values)
    .set_bg("#1e1e2e")
    .show_grid()
    .no_legend()
    .set_font_size(14)
)

Voir Méthodes du graphique pour la référence complète.

Ces méthodes sont disponibles sur chaque objet Chart retourné par n'importe quelle fonction SeraPlot. Elles retournent toutes un nouveau Chart — elles peuvent donc être chaînées librement.

Configuration globale (héritage automatique)

sp.config(**kwargs)

Définie une fois, chaque graphique créé ensuite hérite automatiquement de la configuration. Aucune surcharge par graphique nécessaire.

import seraplot as sp

sp.config(
    font="Inter",
    font_size=14,
    title_size=22,
    crosshair=True,
    zoom=True,
    animation=True,
    animation_duration=500,
    export_button=True,
    responsive=True,
    border_radius=12,
    margin=16,
    opacity=0.85,
    background="#0f172a",
    gridlines=True,
    palette=[0x818CF8, 0xFB7185, 0x34D399, 0xFBBF24],
)

chart1 = sp.bar("Chiffre d'affaires", ["T1", "T2", "T3"], [120, 180, 140])
chart2 = sp.line("Tendance", ["Jan", "Fév", "Mar"], [100, 110, 105])
chart3 = sp.scatter("Corrélation", [1, 2, 3], [10, 20, 30])

sp.reset_config()

Remet toute la configuration globale aux valeurs par défaut (pas de fond, pas de réticule, pas de zoom, etc.).

sp.reset_config()
chart = sp.bar("Propre", labels, values)

Surcharge par graphique (chaînage de méthodes)

Surcharger la configuration globale pour des graphiques individuels :

import seraplot as sp

sp.config(font="Inter", background="#0f172a", gridlines=True)

chart1 = sp.bar("Défaut", labels, values)
chart2 = sp.bar("Surcharge", labels, values).font("Roboto").border_radius(20)
chart3 = sp.line("Propre", dates, values).zoom()

Fond et cadre

set_bg(color=None)

Définit la couleur de fond du wrapper HTML complet, pour plus d'infos une section Background existe dans cette documentation, ou vous pourrez retrouver plus ample information concernant les arrières plan, mais aussi les thèmes existant.

chart = sp.build_bar_chart("Ventes", labels, values).set_bg("#0f172a")
chart = sp.build_scatter_chart("Données", x, y).set_bg("white")
chart = sp.build_pie_chart("Parts", labels, values).set_bg(None)  # transparent

Accepte toute chaîne de couleur CSS : "#rrggbb", "rgb(r,g,b)", couleurs nommées, ou None/"transparent".

set_frame(color=None)

Définit le fond du canevas SVG indépendamment du wrapper HTML. Utile lors d'une intégration dans une page avec son propre fond.

chart = sp.build_bar_chart("Titre", labels, values).set_frame("transparent")

set_global_background(color)

Fonctions au niveau du module qui appliquent un fond à tous les graphiques créés après l'appel — utile pour les sessions notebook avec un thème cohérent.

sp.set_global_background("#0f172a")
chart1 = sp.build_bar_chart(...)
chart2 = sp.build_scatter_chart(...)
sp.reset_global_background()

sp.set_global_background("#0f172a");
const chart1 = sp.build_bar_chart(...);
const chart2 = sp.build_scatter_chart(...);
sp.reset_global_background();

sp.set_global_background("#0f172a");
const chart1 = sp.build_bar_chart(...);
const chart2 = sp.build_scatter_chart(...);
sp.reset_global_background();

Grille et axes

show_grid()

Force l'affichage des lignes de grille indépendamment du paramètre gridlines à la création.

chart = sp.build_histogram("Âges", values).show_grid()

hide_grid()

Force la désactivation des lignes de grille indépendamment du paramètre gridlines à la création.

chart = sp.build_line_chart("Tendance", labels, values, gridlines=True).hide_grid()

no_x_axis()

Supprime les lignes, ticks et étiquettes de l'axe X.

chart = sp.build_bar_chart("", labels, values).no_x_axis()

no_y_axis()

Supprime les lignes, ticks et étiquettes de l'axe Y.

chart = sp.build_bar_chart("", labels, values).no_y_axis()

no_axes()

Supprime les deux axes en une seule fois.

chart = sp.build_scatter_chart("", x, y).no_axes()

Étiquettes et texte

show_labels(position="bottom", labels=None, colors=None)

Affiche une étiquette texte sur chaque élément du graphique. position peut être "top", "bottom", "left" ou "right".

chart = sp.build_bar_chart("Chiffre d'affaires", labels, values).show_labels(position="top")

chart = sp.build_bar_chart("Chiffre d'affaires", labels, values).show_labels(
    position="top",
    labels=["142 k€", "98 k€", "210 k€"],
    colors=["#22c55e", "#ef4444", "#22c55e"],
)

no_title()

Supprime le titre du rendu.

chart = sp.build_pie_chart("Étiquette interne", labels, values).no_title()

no_legend()

Supprime la légende du rendu.

chart = sp.build_grouped_bar("T1", cats, series).no_legend()

set_font_size(px)

Surcharge toutes les tailles de texte du SVG avec une seule valeur en pixels.

chart = sp.build_radar_chart("Compétences", labels, values).set_font_size(11)

Taille et échelle

scale(factor)

Met à l'échelle tout le graphique (SVG et canevas). Utile pour produire des miniatures ou des variantes haute définition.

small = sp.build_bar_chart("Ventes", labels, values).scale(0.5)
large = sp.build_bar_chart("Ventes", labels, values).scale(2.0)

Survol

no_hover()

Désactive le moteur d'infobulles. Tous les événements pointeur data-idx sont retirés. Utile pour des intégrations statiques sans interaction au survol.

chart = sp.build_scatter_chart("Distribution", x, y).no_hover()

Injection CSS et JavaScript

inject_css(css)

Injecte un bloc <style> dans le <head> du HTML. Donne un accès complet au DOM SVG — surcharger n'importe quelle classe interne, changer les couleurs, animations, polices.

Classes CSS internes de SeraPlot :

chart = sp.build_bar_chart("Thème sombre", labels, values).inject_css("""
    rect.sp-bg  { fill: #0f172a !important; }
    svg text    { fill: #e2e8f0 !important; }
    .sp-gl      { stroke: #1e293b !important; }
    [data-idx]  { opacity: 0.85; }
    [data-idx]:hover { filter: brightness(1.3); }
""")

inject_js(js)

Injecte un bloc <script> avant </body>. Tout le DOM SVG rendu est accessible. Utilisez-le pour ajouter des écouteurs d'événements, animations ou intégrations tierces.

chart = sp.build_bar_chart("Ventes", labels, values).inject_js("""
    document.querySelectorAll('[data-idx]').forEach((el, i) => {
        setTimeout(() => el.style.opacity = '1', i * 50);
    });
""")

chart = sp.build_scatter_chart("Données", x, y).inject_js("""
    const btn = document.createElement('button');
    btn.textContent = 'Télécharger SVG';
    btn.onclick = () => {
        const svg  = document.querySelector('svg').outerHTML;
        const a    = document.createElement('a');
        a.href     = 'data:image/svg+xml;charset=utf-8,' + encodeURIComponent(svg);
        a.download = 'chart.svg';
        a.click();
    };
    document.body.appendChild(btn);
""")

Export

save(path)

Écrit le HTML dans un fichier.

chart = sp.build_pie_chart("Parts", labels, values)
chart.save("rapport/pie.html")

to_svg()

Extrait la chaîne SVG brute du HTML.

svg_string = chart.to_svg()

export_svg(path)

Écrit uniquement le SVG dans un fichier (sans le wrapper HTML).

chart.export_svg("chart.svg")

SeraPlot propose 33 graphiques en 2D, 17 en 3D, et 2 types de cartes.

SeraPlot propose 33 types de graphiques 2D, des barres et courbes basiques aux graphiques spécialisés (ridgeline, haltère, slideshow…).

Signature

sp.build_bar_chart(
    title: str,
    labels: list[str],
    values: list[float],
    *,
    color_hex: int = 0,
    orientation: str = "v",
    show_text: bool = False,
    color_groups: list[str] | None = None,
    width: int = 900,
    height: int = 480,
    x_label: str = "",
    y_label: str = "",
    gridlines: bool = False,
    sort_order: str = "none",
    hover_json: str = "",
    legend_position: str = "right",
    palette: list[int] | None = None,
    series_names: list[str] | None = None,
    background: str | None = None,
    no_x_axis: bool = False,
    no_y_axis: bool = False,
) -> Chart

Aliases: sp.bar, sp.bar_chart, sp.bars

Description

Affiche un graphique en barres vertical ou horizontal.

Paramètres

Retourne

Chart — objet avec la propriété .html contenant le HTML autonome complet.

Exemples

Graphique en barres simple

import seraplot as sp

labels = ["Jan", "Fév", "Mar", "Avr", "Mai"]
values = [1200.0, 1850.0, 2100.0, 1750.0, 2400.0]

chart = (
    sp.build_bar_chart(
        "Chiffre d'affaires mensuel",
        labels=labels,
        values=values,
        x_label="Mois",
        y_label="Chiffre d'affaires (€)",
        gridlines=True,
    )
    .set_bg(None)
    .show_labels(position="top")
)

Groupes colorés

chart = sp.build_bar_chart(
    "Produits par catégorie",
    labels=["A1", "A2", "B1", "B2", "C1"],
    values=[10.0, 15.0, 8.0, 12.0, 20.0],
    color_groups=["Cat A", "Cat A", "Cat B", "Cat B", "Cat C"],
    legend_position="bottom",
)

Voir aussi

• Barres horizontales — sp.build_hbar()
• Barres groupées — sp.build_grouped_bar()
• Barres empilées — sp.build_stacked_bar()

Signature

sp.build_hbar(
    title: str,
    labels: list[str],
    values: list[float],
    *,
    color_hex: int = 0,
    show_text: bool = True,
    color_groups: list[str] | None = None,
    width: int = 900,
    height: int = 500,
    x_label: str = "",
    y_label: str = "",
    gridlines: bool = False,
    sort_order: str = "none",
    hover_json: str = "",
    legend_position: str = "right",
    palette: list[int] | None = None,
    background: str | None = None,
    no_x_axis: bool = False,
    no_y_axis: bool = False,
) -> Chart

Aliases: sp.hbar, sp.barh, sp.horizontal_bar

Description

Graphique en barres horizontales. Particulièrement adapté aux longues étiquettes de catégories ou aux classements.

Paramètres

Retourne

Chart

Exemples

Top 10 classement

import seraplot as sp

chart = sp.build_hbar(
    "Top pays par PIB",
    labels=["USA", "Chine", "Allemagne", "Japon", "Inde", "UK", "France", "Brésil", "Canada", "Corée"],
    values=[25.0, 18.0, 4.1, 4.2, 3.7, 3.1, 2.9, 2.1, 2.0, 1.7],
    sort_order="desc",
    x_label="PIB (billions USD)",
    show_text=True,
)

Voir aussi

• Graphique en barres — sp.build_bar_chart()
• Lollipop — sp.build_lollipop_chart()

Signature

sp.build_line_chart(
    title: str,
    labels: list[str],
    values: list[float],
    *,
    color_hex: int = 0x6366F1,
    show_points: bool = True,
    width: int = 900,
    height: int = 480,
    x_label: str = "",
    y_label: str = "",
    gridlines: bool = False,
    sort_order: str = "none",
    hover_json: str = "",
    legend_position: str = "right",
    palette: list[int] | None = None,
    background: str | None = None,
    no_x_axis: bool = False,
    no_y_axis: bool = False,
) -> Chart

Aliases: sp.line, sp.line_chart

Description

Graphique en courbe simple avec points de données optionnels.

Pour plusieurs séries, utilisez build_multiline_chart.

Paramètres

Retourne

Chart

Exemples

import seraplot as sp

mois = ["Jan", "Fév", "Mar", "Avr", "Mai", "Jun",
        "Jul", "Aoû", "Sep", "Oct", "Nov", "Déc"]
revenu = [1200.0, 1350.0, 1100.0, 1600.0, 1800.0, 2100.0,
          1950.0, 2300.0, 2000.0, 2500.0, 2200.0, 2800.0]

chart = (
    sp.build_line_chart(
        "Chiffre d'affaires annuel",
        labels=mois,
        values=revenu,
        x_label="Mois",
        y_label="Chiffre d'affaires (€)",
        gridlines=True,
        color_hex=0x22d3ee,
    )
    .set_bg(None)
)

Voir aussi

• Multi-courbes — sp.build_multiline_chart() pour plusieurs séries
• Graphique en aires — sp.build_area_chart()

Signature

sp.build_area_chart(
    title: str,
    x_labels: list[str],
    series_values: list[list[float]],
    *,
    stacked: bool = False,
    series_names: list[str] | None = None,
    palette: list[int] | None = None,
    width: int = 900,
    height: int = 480,
    x_label: str = "",
    y_label: str = "",
    gridlines: bool = True,
    background: str | None = None,
    legend_position: str = "top",
    hover_json: str | None = None,
) -> Chart

Aliases: sp.area, sp.area_chart

Description

Graphique en aires remplies, optionnellement empilées. Idéal pour visualiser les évolutions cumulatives au fil du temps.

Paramètres

Retourne

Chart

Exemples

Aires empilées

import seraplot as sp

chart = sp.build_area_chart(
    "Chiffre d'affaires empiлé par région",
    x_labels=["T1","T2","T3","T4"],
    series_values=[
        [12000, 14000, 13500, 16000],
        [8000,  9200,  10000, 11500],
        [4500,  5000,  5200,  6000],
    ],
    series_names=["Nord", "Sud", "Est"],
    stacked=True,
    y_label="Chiffre d'affaires (€)",
)

Voir aussi

• Graphique multi-courbes
• Graphique en courbe
• Barres empilées

Signature

sp.build_multiline_chart(
    title: str,
    x_labels: list[str],
    series_values: list[list[float]],
    *,
    show_points: bool = True,
    series_names: list[str] | None = None,
    color_hex: int = 0x6366F1,
    palette: list[int] | None = None,
    width: int = 900,
    height: int = 480,
    x_label: str = "",
    y_label: str = "",
    gridlines: bool = True,
    background: str | None = None,
    no_x_axis: bool = False,
    no_y_axis: bool = False,
    legend_position: str = "top",
    hover_json: str | None = None,
) -> Chart

Aliases: sp.multiline

Description

Graphique multi-courbes — plusieurs séries tracées sur un axe commun. Chaque liste dans series_values doit avoir la même longueur que x_labels.

Paramètres

Retourne

Chart

Exemples

import seraplot as sp

mois = ["Jan","Fév","Mar","Avr","Mai","Jun"]

chart = sp.build_multiline_chart(
    "Chiffre d'affaires mensuel par produit",
    x_labels=mois,
    series_values=[
        [12200, 13400, 15100, 14800, 16200, 17500],
        [8100,  9200,  9800,  10200, 11000, 12400],
        [3200,  3600,  4100,  4500,  4800,  5200],
    ],
    series_names=["Produit A", "Produit B", "Produit C"],
    show_points=True,
    y_label="Chiffre d'affaires (€)",
)

Voir aussi

• Graphique en courbe
• Graphique en aires

Signature

sp.build_scatter_chart(
    title: str,
    x_values: list[float],
    y_values: list[float],
    *,
    color_hex: int = 0,
    show_text: bool = False,
    labels: list[str] | None = None,
    sizes: list[float] | None = None,
    color_groups: list[str] | None = None,
    width: int = 900,
    height: int = 480,
    x_label: str = "",
    y_label: str = "",
    gridlines: bool = False,
    sort_order: str = "none",
    hover_json: str = "",
    legend_position: str = "right",
    palette: list[int] | None = None,
    background: str | None = None,
    no_x_axis: bool = False,
    no_y_axis: bool = False,
    show_regression: bool = False,
    regression_type: str = "linear",
) -> Chart

Aliases: sp.scatter, sp.scatter_chart

Description

Nuage de points 2D avec taille par point, regroupement, étiquettes et droite de régression optionnels.

Paramètres

Retourne

Chart

Exemples

import seraplot as sp
import numpy as np

rng = np.random.default_rng(0)
x_a = rng.normal(0, 1, 200).tolist()
y_a = [xi * 1.5 + rng.normal() for xi in x_a]
x_b = rng.normal(3, 1, 200).tolist()
y_b = [xi * 0.5 + rng.normal() for xi in x_b]

chart = sp.build_scatter_chart(
    "Deux populations",
    x_values=x_a + x_b,
    y_values=y_a + y_b,
    color_groups=["Groupe A"] * 200 + ["Groupe B"] * 200,
    show_regression=True,
    regression_type="linear",
    x_label="X",
    y_label="Y",
)

Voir aussi

• DBSCAN 2D — clustering automatique sur données de nuage de points
• Bulles — nuage de points avec troisième dimension de taille
• Nuage de points 3D

Signature

sp.build_histogram(
    title: str,
    values: list[float],
    *,
    color_hex: int = 0,
    bins: int = 20,
    show_counts: bool = False,
    width: int = 900,
    height: int = 480,
    x_label: str = "",
    y_label: str = "",
    gridlines: bool = False,
    sort_order: str = "none",
    hover_json: str = "",
    legend_position: str = "right",
    palette: list[int] | None = None,
    background: str | None = None,
    no_x_axis: bool = False,
    no_y_axis: bool = False,
) -> Chart

Aliases: sp.hist, sp.histogram

Description

Histogramme de distribution avec nombre de classes (bins) configurable.

Paramètres

Retourne

Chart

Exemples

Distribution normale

import seraplot as sp
import numpy as np

data = np.random.normal(0, 1, 5000).tolist()

chart = sp.build_histogram(
    "Distribution normale — N(0,1)",
    values=data,
    bins=40,
    x_label="Valeur",
    y_label="Effectif",
    gridlines=True,
    show_counts=False,
)

Voir aussi

• Histogramme superposé — comparer deux distributions
• KDE — estimation de densité lisse
• Violon — distribution par catégorie

Signature

sp.build_histogram_overlay(
    title: str,
    values: list[float],
    overlay_values: list[float],
    *,
    color_hex: int = 0,
    overlay_color_hex: int = 0,
    bins: int = 20,
    series_names: list[str] | None = None,
    width: int = 900,
    height: int = 480,
    x_label: str = "",
    y_label: str = "",
    gridlines: bool = False,
    palette: list[int] | None = None,
    background: str | None = None,
    no_x_axis: bool = False,
    no_y_axis: bool = False,
) -> Chart

Aliases: sp.histogram_overlay

Description

Histogramme superposé pour comparer deux distributions avec transparence.

Paramètres

Retourne

Chart

Exemples

import seraplot as sp
import numpy as np

rng = np.random.default_rng(42)
controle   = rng.normal(5.0, 1.0, 1000).tolist()
traitement = rng.normal(5.8, 1.2, 1000).tolist()

chart = sp.build_histogram_overlay(
    "Contrôle vs Traitement",
    values=controle,
    overlay_values=traitement,
    bins=30,
    series_names=["Contrôle", "Traitement"],
    x_label="Mesure",
    y_label="Fréquence",
    gridlines=True,
)

Voir aussi

• Histogramme
• KDE

Signature

sp.build_grouped_bar(
    title: str,
    category_labels: list[str],
    series_values: list[float],
    *,
    show_values: bool = False,
    series_names: list[str] | None = None,
    width: int = 900,
    height: int = 480,
    x_label: str = "",
    y_label: str = "",
    gridlines: bool = False,
    sort_order: str = "none",
    hover_json: str = "",
    legend_position: str = "right",
    palette: list[int] | None = None,
    background: str | None = None,
    no_x_axis: bool = False,
    no_y_axis: bool = False,
) -> Chart

Aliases: sp.grouped_bar

Description

Graphique en barres groupées pour comparer plusieurs séries sur les mêmes catégories.

series_values doit être une liste plate de longueur n_catégories × n_séries, en ordre catégorie-major.

Paramètres

Retourne

Chart

Exemples

import seraplot as sp

categories = ["T1", "T2", "T3", "T4"]
valeurs = [
    120.0, 90.0, 150.0,
    130.0, 110.0, 140.0,
    100.0, 95.0,  160.0,
    140.0, 120.0, 175.0,
]

chart = (
    sp.build_grouped_bar(
        "Ventes trimestrielles par produit",
        category_labels=categories,
        series_values=valeurs,
        series_names=["Produit A", "Produit B", "Produit C"],
        show_values=True,
        gridlines=True,
        legend_position="bottom",
    )
    .set_bg(None)
)

Voir aussi

• Barres empilées — sp.build_stacked_bar()
• Graphique en barres

Signature

sp.build_stacked_bar(
    title: str,
    category_labels: list[str],
    series_values: list[float],
    *,
    show_values: bool = False,
    series_names: list[str] | None = None,
    width: int = 900,
    height: int = 480,
    x_label: str = "",
    y_label: str = "",
    gridlines: bool = False,
    sort_order: str = "none",
    hover_json: str = "",
    legend_position: str = "right",
    palette: list[int] | None = None,
    background: str | None = None,
    no_x_axis: bool = False,
    no_y_axis: bool = False,
) -> Chart

Aliases: sp.stacked_bar

Description

Graphique en barres empilées. Chaque barre est divisée en segments représentant les contributions des séries.

Même disposition plate series_values que build_grouped_bar.

Paramètres

Retourne

Chart

Exemples

import seraplot as sp

mois = ["Jan", "Fév", "Mar"]
coûts = [
    400.0, 150.0, 80.0,
    380.0, 170.0, 95.0,
    420.0, 160.0, 90.0,
]

chart = sp.build_stacked_bar(
    "Coûts mensuels",
    category_labels=mois,
    series_values=coûts,
    series_names=["Main-d\'oeuvre", "Matériaux", "Frais généraux"],
    legend_position="right",
    gridlines=True,
)

Voir aussi

• Barres groupées
• Barres empilées 3D

Signature

sp.build_heatmap(
    title: str,
    labels: list[str],
    flat_matrix: list[float],
    *,
    show_values: bool = True,
    color_low: int = 0,
    color_mid: int = 0,
    color_high: int = 0,
    col_labels: list[str] | None = None,
    width: int = 900,
    height: int = 480,
    x_label: str = "",
    y_label: str = "",
    gridlines: bool = False,
    palette: list[int] | None = None,
    background: str | None = None,
    no_x_axis: bool = False,
    no_y_axis: bool = False,
) -> Chart

Aliases: sp.heatmap

Description

Matrice colorée (heatmap). Les valeurs sont normalisées automatiquement pour le mappage de couleurs.

flat_matrix doit contenir n_lignes × n_colonnes valeurs en ordre ligne-major. labels = étiquettes de lignes. col_labels = étiquettes de colonnes.

Paramètres

Retourne

Chart

Exemples

Matrice de corrélation

import seraplot as sp
import numpy as np

features = ["Age", "Revenu", "Score", "Visites"]
matrice = np.corrcoef(np.random.randn(4, 100)).flatten().tolist()

chart = sp.build_heatmap(
    "Matrice de corrélation des variables",
    labels=features,
    flat_matrix=matrice,
    color_low=0x3b82f6,
    color_mid=0xffffff,
    color_high=0xef4444,
    show_values=True,
)

Voir aussi

• Carte de chaleur 3D

Signature

sp.build_pie_chart(
    title: str,
    labels: list[str],
    values: list[float],
    *,
    show_pct: bool = True,
    width: int = 700,
    height: int = 480,
    palette: list[int] | None = None,
    background: str | None = None,
    hover_json: str | None = None,
    legend_position: str = "right",
) -> Chart

Aliases: sp.pie, sp.pie_chart

Description

Camembert standard avec étiquettes de pourcentage optionnelles.

Paramètres

Retourne

Chart

Exemples

import seraplot as sp

chart = sp.build_pie_chart(
    "Chiffre d'affaires par région",
    labels=["Nord", "Sud", "Est", "Ouest"],
    values=[30, 25, 20, 25],
    palette=[0x6366f1, 0x22d3ee, 0xf43f5e, 0xf59e0b],
    legend_position="bottom",
)

Voir aussi

• Anneau
• Camembert 3D
• Sunburst

Signature

sp.build_donut_chart(
    title: str,
    labels: list[str],
    values: list[float],
    *,
    show_pct: bool = True,
    inner_radius_ratio: float = 0.55,
    width: int = 700,
    height: int = 480,
    palette: list[int] | None = None,
    background: str | None = None,
    hover_json: str | None = None,
    legend_position: str = "right",
) -> Chart

Aliases: sp.donut, sp.donut_chart

Description

Diagramme en anneau — identique à un camembert avec un trou circulaire central. inner_radius_ratio contrôle la taille du trou (0.0 = camembert plein, 1.0 = anneau invisible).

Paramètres

Retourne

Chart

Exemples

import seraplot as sp

chart = sp.build_donut_chart(
    "Répartition du budget",
    labels=["R&D", "Marketing", "Opérations", "Support"],
    values=[35, 25, 30, 10],
    inner_radius_ratio=0.55,
    show_pct=True,
)

Voir aussi

• Camembert
• Sunburst

Signature

sp.build_boxplot(
    title: str,
    category_labels: list[str],
    values: list[float],
    *,
    width: int = 900,
    height: int = 480,
    x_label: str = "",
    y_label: str = "",
    color_hex: int = 0x6366F1,
    palette: list[int] | None = None,
    background: str | None = None,
    gridlines: bool = True,
    no_x_axis: bool = False,
    no_y_axis: bool = False,
) -> Chart

Aliases: sp.boxplot, sp.box_plot

Description

Boite à moustaches montrant la distribution statistique par catégorie. Chaque boîte affiche Q1, la médiane, Q3 et les moustaches IQR.

values est une liste plate concaténant tous les échantillons de toutes les catégories (même nombre de valeurs par catégorie).

Paramètres

Retourne

Chart

Exemples

Résultats de tests par classe

import seraplot as sp
import random

n = 50
groupes = {
    "Classe A": [random.gauss(72, 10) for _ in range(n)],
    "Classe B": [random.gauss(68, 15) for _ in range(n)],
    "Classe C": [random.gauss(80, 8)  for _ in range(n)],
}

labels = list(groupes.keys())
values = [v for g in groupes.values() for v in g]

chart = sp.build_boxplot(
    "Distribution des scores par classe",
    category_labels=labels,
    values=values,
    y_label="Score",
    gridlines=True,
)

Voir aussi

• Violon
• Histogramme
• KDE

Signature

sp.build_violin(
    title: str,
    categories: list[str],
    values: list[float],
    *,
    width: int = 900,
    height: int = 480,
    x_label: str = "",
    y_label: str = "",
    color_hex: int = 0x6366F1,
    palette: list[int] | None = None,
    background: str | None = None,
    gridlines: bool = True,
    bandwidth: float = 1.0,
) -> Chart

Aliases: sp.violin

Description

Graphique en violon combinant estimation KDE et résumé de boîte à moustaches. La forme en miroir montre la distribution complète de chaque groupe.

Paramètres

Retourne

Chart

Exemples

Comparaison des distributions de salaires

import seraplot as sp
import random

postes = {
    "Ingénieur":  [random.gauss(95000, 15000) for _ in range(60)],
    "Manager":    [random.gauss(110000, 20000) for _ in range(60)],
    "Analyste":   [random.gauss(75000, 12000) for _ in range(60)],
}

chart = sp.build_violin(
    "Distribution des salaires par poste",
    categories=list(postes.keys()),
    values=[v for g in postes.values() for v in g],
    y_label="Salaire (€)",
    palette=[0x6366f1, 0x22d3ee, 0xf43f5e],
)

Voir aussi

• Boîte à moustaches
• KDE
• Ridgeline
• Violon 3D

Signature

sp.build_kde_chart(
    title: str,
    values: list[float],
    *,
    color_hex: int = 0x6366F1,
    bandwidth: float = 1.0,
    fill: bool = True,
    width: int = 900,
    height: int = 480,
    x_label: str = "",
    y_label: str = "Density",
    gridlines: bool = True,
    background: str | None = None,
    palette: list[int] | None = None,
    series_names: list[str] | None = None,
) -> Chart

Aliases: sp.kde

Description

Courbe d'estimation par noyau (KDE) — estimation lissée et continue d'une distribution de probabilité. Plus informative qu'un histogramme pour identifier la forme sous-jacente des données.

Plusieurs séries peuvent être superposées via series_names.

Paramètres

Retourne

Chart

Exemples

Distribution simple

import seraplot as sp
import random

valeurs = [random.gauss(50, 10) for _ in range(500)]

chart = sp.build_kde_chart(
    "Distribution des scores",
    values=valeurs,
    x_label="Score",
    bandwidth=1.0,
)

Voir aussi

• Histogramme
• Violon
• Ridgeline
• KDE 3D

Signature

sp.build_ridgeline_chart(
    title: str,
    categories: list[str],
    values: list[float],
    *,
    bandwidth: float = 1.0,
    overlap: float = 0.5,
    color_hex: int = 0x6366F1,
    palette: list[int] | None = None,
    width: int = 900,
    height: int = 480,
    x_label: str = "",
    background: str | None = None,
    gridlines: bool = False,
) -> Chart

Aliases: sp.ridgeline

Description

Graphique ridgeline (joy plot) — courbes KDE empilées par catégorie. Excellent pour comparer les formes de distribution entre de nombreux groupes.

values est une liste plate. Le nombre de valeurs doit être divisible par len(categories) (échantillons égaux par groupe).

Paramètres

Retourne

Chart

Exemples

import seraplot as sp
import random

mois = ["Jan", "Avr", "Jul", "Oct"]
moyennes = [5, 15, 28, 16]

valeurs = [v for m in moyennes for v in [random.gauss(m, 4) for _ in range(100)]]

chart = sp.build_ridgeline_chart(
    "Distribution de température mensuelle",
    categories=mois,
    values=valeurs,
    overlap=0.6,
    x_label="°C",
)

Voir aussi

• KDE
• Violon
• Ridgeline 3D

Signature

sp.build_radar_chart(
    title: str,
    axes: list[str],
    series: list[list[float]],
    *,
    series_names: list[str] | None = None,
    palette: list[int] | None = None,
    fill_opacity: float = 0.25,
    width: int = 600,
    height: int = 500,
    background: str | None = None,
    max_val: float | None = None,
) -> Chart

Aliases: sp.radar, sp.radar_chart

Description

Graphique radar (toile d'araignée) — un polygone par série sur des axes radiaux. Idéal pour profiler des entités sur plusieurs dimensions simultanément.

Paramètres

Retourne

Chart

Exemples

import seraplot as sp

chart = sp.build_radar_chart(
    "Comparaison des statistiques joueurs",
    axes=["Vitesse", "Force", "Défense", "Dribble", "Tir", "Passe"],
    series=[[85, 70, 65, 90, 88, 82], [72, 88, 79, 68, 75, 85]],
    series_names=["Joueur A", "Joueur B"],
    palette=[0x6366f1, 0xf43f5e],
)

Voir aussi

• Coordonnées parallèles
• Radar 3D

Signature

sp.build_bubble(
    title: str,
    x_values: list[float],
    y_values: list[float],
    sizes: list[float],
    *,
    labels: list[str] | None = None,
    color_groups: list[str] | None = None,
    color_hex: int = 0x6366F1,
    palette: list[int] | None = None,
    width: int = 900,
    height: int = 480,
    x_label: str = "",
    y_label: str = "",
    gridlines: bool = True,
    background: str | None = None,
    hover_json: str | None = None,
) -> Chart

Aliases: sp.bubble

Description

Graphique à bulles : nuage de points où la surface de chaque point encode une troisième dimension (sizes).

Paramètres

Retourne

Chart

Exemples

Style Gapminder

import seraplot as sp

pays = ["USA", "Chine", "Allemagne", "Inde", "Brésil"]
pib       = [65000, 12500, 48000, 2100, 8800]
esp_vie   = [78.5, 77.1, 81.3, 69.7, 75.2]
population= [331, 1412, 83, 1380, 212]

chart = sp.build_bubble(
    "PIB vs Espérance de vie (2023)",
    x_values=pib,
    y_values=esp_vie,
    sizes=[p / 10 for p in population],
    color_groups=pays,
    x_label="PIB par habitant ($)",
    y_label="Espérance de vie (ans)",
)

Voir aussi

• Nuage de points
• Carte à bulles
• Bulles 3D

Signature

sp.build_slope(
    title: str,
    labels: list[str],
    values_left: list[float],
    values_right: list[float],
    left_label: str,
    right_label: str,
    *,
    show_text: bool = True,
    color_hex: int = 0x6366F1,
    palette: list[int] | None = None,
    width: int = 600,
    height: int = 480,
    background: str | None = None,
) -> Chart

Aliases: sp.slope

Description

Graphique de pente comparant deux valeurs par entité (avant/après, période A vs B). Les axes verticaux parallèles sont reliés par des lignes de pente montantes ou descendantes.

Paramètres

Retourne

Chart

Exemples

import seraplot as sp

chart = sp.build_slope(
    "IDH : Évolution 2000–2023",
    labels=["Allemagne", "Japon", "Brésil", "Inde", "Nigéria"],
    values_left=[0.926, 0.909, 0.694, 0.493, 0.452],
    values_right=[0.950, 0.920, 0.760, 0.644, 0.548],
    left_label="2000",
    right_label="2023",
    show_text=True,
)

Voir aussi

• Graphique en courbe
• Haltère