Pourquoi un seul moteur plutôt que trois bibliothèques

Plotly, scikit-learn et pandas sont chacun excellents dans leur domaine — et chacun est une bibliothèque séparée avec son propre modèle d’objets. Les connecter implique de convertir des DataFrames en tableaux NumPy puis en listes et inversement, à chaque frontière. Sera existe parce que ce coût de conversion est réel, et parce qu’un graphique, un modèle entraîné et la table qui a nourri les deux n’ont pas besoin de vivre dans des mondes différents.

sp.kmeans() calcule le clustering et rend le graphique dans le même appel Rust — aucun aller-retour vers scikit-learn, aucune sérialisation intermédiaire. C’est tout le principe de conception derrière Sera : construire une seule fois, nativement, et laisser chaque pilier appeler les autres directement.

Comment bien développer avec Sera

Les trois piliers partagent les mêmes conventions volontairement, pour que passer de l’un à l’autre ne coûte rien :

• Un appel, un résultat. sp.bar(...), sp.linear_regression(...), df.groupby(...) suivent tous la même forme de fonction à plat — pas d’objet builder à assembler d’abord, pas de .fit() puis .transform() séparés sauf si l’algorithme a réellement besoin d’état entre les appels.
• Les alias sont gratuits. Chaque fonction est accessible sous plusieurs noms (sp.bar / sp.bars / sp.bar_chart / sp.bar_unified) résolus via un registre d’alias partagé — choisissez le nom qui se lit le mieux dans votre code, ils compilent vers le même appel.
• Sortie native, toujours. Un graphique est du vrai HTML/SVG, un résultat de modèle est un vrai dict Python, une colonne de DataFrame est de la vraie mémoire portée par Rust — jamais un objet wrapper opaque qu’il faut déballer pour accéder à la donnée réelle.
• Le chemin le plus ergonomique est le chemin le plus rapide. Parce que le calcul se fait en Rust avant de traverser vers Python, la façon la plus naturelle d’écrire du code et la façon la plus rapide sont le même code.

Le contrôleur : un appel de config, tous les graphiques obéissent

Chaque pilier lit depuis le même contrôleur global plutôt que de répéter les options à chaque appel. Configurez une fois — police, palette, animation, locale — et chaque Chart construit ensuite hérite automatiquement, tout en restant libre de surcharger une valeur localement.

import seraplot as sp

sp.config(
    font="Inter", font_size=13,
    palette="viridis", background="#0d1117",
    animation=True, animation_duration=420,
    crosshair=True, zoom=True, tooltip=True,
    locale="fr-FR", thousands_sep=" ",
    responsive=True, export_button=True,
)

sp.bar("Revenu", labels, values)                  # hérite de tous les réglages ci-dessus
sp.bar("Revenu", labels, values, font_size=16)     # surcharge juste celui-ci

sp.config() expose 30+ réglages de cette façon — typographie, palette/fond, gridlines et despine, formatage/rotation automatique du texte, rayon des coins de barre, watermark, ombre portée, comportement crosshair/zoom/tooltip, formatage numérique localisé, mise en page responsive, visibilité du bouton d’export. sp.reset_config() revient aux défauts, sp.theme() change tout un preset en un appel. Voir Méthodes des graphiques pour la référence complète du contrôleur et chaque méthode chainable par graphique, et Configuration pour la surface de config en détail.

Accessibilité et compatibilité navigateur, réellement vérifiées

Pas une affirmation — vérifié ainsi : axe-core s’exécute contre un vrai Chromium pour chaque famille de graphique, zéro violation serious/critical ; le contraste texte et non-texte est mesuré (luminance relative, pas à l’œil) contre WCAG AA ; la navigation clavier (tabindex flottant, flèches/Home/End) fonctionne sur les points de données et les légendes ; tout le catalogue charge sans erreur console sur de vrais moteurs Chromium, Firefox et WebKit, pas un seul.

À voir en action

Par où commencer

• Installation — pip install seraplot
• Démarrage rapide — premier graphique en 3 lignes
• Intro SeraPlot — le moteur de graphiques en détail, avec benchmarks face à face
• Vitrine — toutes les familles de graphiques et variantes, avec un aperçu image
• Machine Learning — le catalogue d’estimateurs SeraML
• SeraDFrame — le dataframe natif

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.

Installer

pip install seraplot

pip install seraplot

pip install --upgrade seraplot

uv add seraplot

conda install -c conda-forge seraplot

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.

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

À voir en action

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

Définis les défauts une fois. Tous les graphiques créés ensuite héritent automatiquement de cette configuration.

sp.config.add_alias("bar", "barchart")
sp.config.add_alias("line", "linechart")
sp.config.save()  # écrit dans ~/.seraplot/config.json

import seraplot as sp  # les aliases sont rechargés automatiquement

Préréglages combinant palette, fond et grille.

sp.config(theme="dark", gridlines=True, font="Inter")
chart = sp.bar("Ventes", labels=["Q1","Q2","Q3"], values=[120,180,150])
chart.show()

Chaque carte ci-dessous est générée directement depuis l’annotation #[sera_doc(…)] de la méthode Rust correspondante — nom, paramètres et description correspondent toujours à l’implémentation réelle.

src = chart.html

print(len(chart))

if chart:
    chart.show()

chart = sp.line(
    "Ventes", labels=mois, values=ventes,
    annotations=[
        {"kind":"hline", "y":0.5, "color":"#22c55e", "dash":"6 4", "text":"Cible"},
        {"kind":"vline", "x":0.62, "color":"#f59e0b", "text":"Lancement"},
        {"kind":"rect",  "x":0.05, "y":0.65, "x2":0.40, "y2":0.92,
                         "color":"#6366f1", "fill":"#6366f1", "opacity":0.10},
        {"kind":"arrow", "x":0.45, "y":0.30, "x2":0.85, "y2":0.18, "color":"#ef4444"},
        {"kind":"text",  "x":0.46, "y":0.28, "text":"Outlier", "color":"#ef4444"},
    ],
)

bar  = sp.bar("Ventes-Q", labels=["Q1","Q2","Q3","Q4"], values=[120,180,150,210])
line = sp.line("Tendance", labels=mois, values=ventes)
pie  = sp.pie("Mix", labels=["A","B","C"], values=[40,35,25])
sp.grid([bar, line, pie], cols=3, gap=14, title="Tableau de bord").show()

slides = [sp.bar(f"Slide {i+1}", labels=["A","B"], values=[i, i+1]) for i in range(4)]
sp.build_slideshow(slides, interval_ms=2200, title="Histoire trimestrielle").show()

Deux couches, et chaque page de cette section précise laquelle elle documente :

• Fonctions globales autonomes — sp.set_global_background(...), sp.theme(...), sp.config(...) — s’appliquent avant la construction des graphiques et affectent tout ce qui est créé ensuite. Voir Méthodes des graphiques pour la liste complète générée.
• Méthodes chaînables sur Chart — chart.export_svg(path), chart.hover_json(payload), chart.downsample() — s’appliquent à un chart déjà construit et retournent un nouveau Chart, comme toute autre méthode par graphique.

Chaque exemple de code de cette section est vérifié contre un vrai build plutôt qu’écrit de mémoire — quand une fonctionnalité n’existe que côté JS/WASM, ou n’est pas encore câblée comme fonction Python, c’est dit explicitement plutôt que présenté comme si ça fonctionnait.

Fonctions

Exemple

import seraplot as sp

sp.set_global_background("#0f172a")

barre = sp.build_bar_chart("Revenus", labels=["A", "B"], values=[300, 200])
camembert = sp.build_pie_chart("Parts", labels=["A", "B"], values=[60, 40])

sp.reset_global_background()

sp.set_global_background(...) équivaut à sp.config(background=...), et est écrasé par sp.theme(name) si un thème est appliqué ensuite — voir Thèmes pour la liste des thèmes intégrés (fond + palette + quadrillage).

Aperçu

SeraPlot représente les couleurs sous forme d’entiers RGB 24 bits (int) ou de chaînes CSS (str).

Palettes intégrées

Il n’existe pas de constante sp.PALETTE_* autonome — les jeux de couleurs intégrés sont livrés à l’intérieur d’un thème (fond + palette + quadrillage ensemble). Appelez sp.theme(name) pour en appliquer un, ou consultez Thèmes pour la liste complète et les valeurs hex exactes de chaque palette.

import seraplot as sp

print(sp.themes())
# ['dark', 'light', 'scientific', 'apple', 'notion', 'minimal', 'neon']

sp.theme("dark")
chart = sp.build_bar_chart("Revenus", labels=["A", "B", "C"], values=[100, 200, 150])
sp.reset_theme()

Passez n’importe quelle liste d’entiers hex comme paramètre palette pour surcharger la palette d’un seul chart, indépendamment du thème actif :

chart = sp.build_bar_chart(
    "Revenus",
    labels=["A","B","C"],
    values=[100,200,150],
    palette=[0x6366f1, 0x22d3ee, 0xf43f5e],
)

Référence des paramètres de couleur

Exemple

import seraplot as sp

chart = sp.build_heatmap(
    "Corrélation",
    labels=["A","B","C"],
    col_labels=["A","B","C"],
    values=[1, 0.8, 0.2, 0.8, 1, 0.5, 0.2, 0.5, 1],
    color_low=0xfaf5ff,
    color_mid=0xa78bfa,
    color_high=0x4c1d95,
)

API

import seraplot as sp

sp.theme("dark")
graphique = sp.bar("Revenus", labels=["T1", "T2", "T3"], values=[120, 145, 98])

sp.reset_theme()

Les 7 thèmes disponibles

Palettes complètes

Exemples

import seraplot as sp

sp.theme("dark")
sp.bar("Revenus", labels=["T1", "T2", "T3", "T4"], values=[120, 145, 98, 180]).show()

sp.theme("neon")
sp.scatter(title="Clusters", x=[1, 2, 3, 4, 5, 6], y=[2, 5, 3, 8, 7, 9]).show()

sp.theme("scientific")
sp.line(title="Croissance démographique", x_labels=["2020", "2021", "2022", "2023"], values=[100, 112, 121, 135]).show()

sp.reset_theme()

print(sp.themes())
# ['dark', 'light', 'scientific', 'apple', 'notion', 'minimal', 'neon']

Notes

• sp.theme() définit le fond global, la palette et le quadrillage. C’est équivalent à sp.config(background=..., palette=..., gridlines=...) avec les valeurs du préréglage.
• Les thèmes persistent jusqu’à sp.reset_theme() ou un appel sp.config() qui les écrase.
• Vous pouvez continuer à surcharger des propriétés individuelles après avoir appliqué un thème :

sp.theme("dark")
sp.config(font_size=16, border_radius=12)

Signature

chart.hover_json(slots_json: str) -> Chart

hover_json est une méthode chaînable sur Chart — pas une fonction sp. autonome. Elle prend une seule chaîne JSON et retourne un nouveau Chart avec l’override de tooltip appliqué, la même forme chaînable que toute autre méthode Chart (chart.subtitle(...).hover_json(...).show()).

Description

Remplace le contenu du tooltip affiché par point de donnée, indépendamment des valeurs réellement tracées — utile quand la combinaison label/valeur des axes ne raconte pas toute l’histoire (formatage monétaire, un delta vs la période précédente, une catégorie absente du graphique lui-même).

Exemple

import json
import seraplot as sp

chart = sp.bar(title="Revenus par produit", labels=["Alpha", "Beta", "Gamma"], values=[420, 380, 290])

hover_payload = json.dumps({
    "fields": ["Produit", "Revenu (€)", "Croissance"],
    "values": [
        ["Alpha", 420, "+12%"],
        ["Beta",  380, "+5%"],
        ["Gamma", 290, "-3%"],
    ],
})

chart = chart.hover_json(hover_payload)

Signature

sp.set_auto_display(enabled: bool) -> None

Description

Contrôle si les objets Chart sont automatiquement rendus dans les cellules Jupyter.

Paramètres

Exemples

sp.set_auto_display(False)
graphiques = []
for nom, valeurs in jeux_de_donnees.items():
    graphiques.append(sp.build_bar_chart(nom, labels=["A","B","C"], values=valeurs))
for g in graphiques:
    g.show()

Réduit les datasets massifs en préservant la forme visuelle avec l’algorithme Largest-Triangle-Three-Buckets. Un scatter de 10M points devient 5K points indistinguables à l’œil.

Python

import seraplot as sp

chart = sp.scatter(title="Grand scatter", x_values=big_x, y_values=big_y).downsample()

downsample est une méthode chaînable sur Chart, pas une fonction sp. autonome — il n’y a pas de sp.lttb() en Python ; l’algorithme n’est enregistré que côté JS/WASM aujourd’hui (downsampleLttb, ci-dessous).

JavaScript

import { downsampleLttb } from "seraplot";
const reduced = JSON.parse(downsampleLttb(JSON.stringify({ x, y, threshold: 5000 })));

Pourquoi LTTB ?

LiveStream est un accumulateur à buffer circulaire borné qui transforme une série d’échantillons (x, y) arrivant dans le temps en un graphique redessiné en continu. La mémoire reste constante quelle que soit la durée du flux, puisque les échantillons les plus anciens sont supprimés au-delà de max_points.

Ce qui le rend fluide dans un notebook : push() / extend() / clear() ne font pas que re-rendre — ils repeignent la même cellule de sortie Jupyter sur place via le mécanisme display_id d’IPython (display() une fois, puis update_display() à chaque appel suivant). Aucune nouvelle cellule n’est ajoutée, pas de saut de défilement, pas de clear-puis-flash ; le graphique se met à jour là où il est déjà.

Constructeur

sp.LiveStream(
    kind: str = "line",        # "line" ou "scatter"
    title: str = "",
    max_points: int = 500,      # taille du buffer circulaire
    color_hex: int = 0x6366F1,
    width: int = 900,
    height: int = 420,
)

Méthodes

Chaque appel mutant applique la limite max_points en supprimant d’abord les échantillons les plus anciens — le buffer est donc toujours borné.

Exemple : tableau de bord IoT live dans Jupyter

import seraplot as sp
import time, random

stream = sp.LiveStream(kind="line", title="Capteur de température (°C)", max_points=60)

value = 21.0
for tick in range(300):
    value += random.uniform(-0.4, 0.4)
    stream.push(tick, value)
    time.sleep(0.05)

Exécute ceci dans une seule cellule de notebook : le graphique apparaît une fois, puis se met à jour de manière fluide sur place à chaque push() — sans scintillement, sans nouvelle cellule de sortie.

Voir v2/examples/iot_live_dashboard.py pour une simulation multi-capteurs plus complète.

Compare deux charts structurellement — utile pour les CI visuelles / tests de régression. Implémenté nativement en Rust (plot::utils::chart_diff).

chart_diff n’est aujourd’hui câblé que pour le build WASM/JS — pas encore exposé comme méthode Python (Chart.diff() n’existe pas). Documenté tel quel plutôt que masqué derrière un exemple Python qui ne s’exécuterait pas.

JavaScript / WASM

import { chartDiff } from "seraplot";

const result = JSON.parse(chartDiff(JSON.stringify({ a: htmlA, b: htmlB })));
console.log(result);

Retourne :

{
  "ok": true,
  "identical": false,
  "size_a": 4521,
  "size_b": 4523,
  "common_prefix": 4400,
  "similarity": 0.97
}

a/b sont comparés sur la tranche <svg>...</svg> extraite du .html de chaque chart. common_prefix est le nombre d’octets identiques au début des deux SVG avant la première différence ; similarity est cette longueur commune divisée par la plus longue des deux.

Détecte un drift de distribution entre un dataset de référence et un dataset actuel via le test à deux échantillons de Kolmogorov-Smirnov — implémenté nativement en Rust (plot::utils::drift_ks).

drift_ks n’est aujourd’hui câblé que pour le build WASM/JS — pas encore exposé comme fonction Python (sp.drift n’existe pas). Documenté tel quel plutôt que masqué derrière un exemple Python qui ne s’exécuterait pas.

JavaScript / WASM

import { driftKs } from "seraplot";

const r = JSON.parse(driftKs(JSON.stringify({ reference, current })));
console.log(r);

Retourne :

{
  "ok": true,
  "ks_statistic": 0.18,
  "p_value": 0.003,
  "drift_detected": true,
  "n_reference": 1000,
  "n_current": 1000
}

drift_detected est true quand p_value < 0.05.

L’export est exposé de deux façons : comme méthodes sur Chart en Python (vérifié ci-dessous contre un vrai build), et comme fonctions autonomes enregistrées via for_each_fn!, appelables depuis JavaScript / le C-FFI. Les deux ne sont pas un miroir 1:1 aujourd’hui — chart_info est la seule fonction réellement appelable des deux côtés.

chart.save(path) / chart.export_html(path)

Écrit l’intégralité du HTML du chart sur disque. Le fichier est auto-suffisant : il embarque le SVG, ses scripts et ses styles. Il s’ouvre dans n’importe quel navigateur, peut être joint à un mail ou servi en statique — aucun serveur, aucun CDN.

import seraplot as sp

chart = sp.bar(title="Chiffre d'affaires", labels=["T1", "T2"], values=[120, 180])
chart.save("revenue.html")

chart.export_svg(path)

Extrait le bloc <svg>...</svg> du chart et l’écrit sous path. Utile pour l’intégrer dans un flux LaTeX / Word / Illustrator, ou post-traiter la géométrie (overrides CSS, masques, filtres custom).

chart.export_svg("plot.svg")

chart.export_png(path)

Rasterise le chart en PNG via cairosvg. Nécessite pip install cairosvg — lève une erreur claire nommant la dépendance manquante plutôt que d’échouer silencieusement.

chart.export_png("plot.png")

sp.chart_info(chart) -> str

Retourne une chaîne JSON contenant des métadonnées structurelles sur le chart rendu. Pratique pour le logging, la télémétrie ou pour tester la complexité d’un chart dans des tests unitaires.

import json

info = json.loads(sp.chart_info(chart))
print(info)

{"size": 25488, "paths": 0, "rects": 3, "circles": 0, "has_svg": true}

JavaScript

Seuls buildBarChart (et l’équivalent build* par famille de chart) et exportHtmlFile sont enregistrés côté JS/WASM aujourd’hui — pas encore d’équivalent JS pour export_svg/export_png/chart_info.

import * as sp from "seraplot";

const chart = sp.buildBarChart(JSON.stringify({
  title: "Chiffre d'affaires",
  labels: ["T1", "T2"],
  values: [120, 180],
}));

exportHtmlFile existe mais échoue toujours à l’exécution aujourd’hui — le crate cible wasm32-unknown-unknown, qui n’a aucun accès au système de fichiers pour appuyer std::fs::write, ni dans Node ni dans le navigateur :

sp.exportHtmlFile(JSON.stringify({ html: chart, path: "out.html" }));
// => '{"ok":false,"error":"operation not supported on this platform"}'

Écrivez plutôt la chaîne HTML retournée sur disque côté JS (fs.writeFileSync("out.html", chart) en Node, ou un téléchargement Blob dans le navigateur).

sp.ml_save_model() / sp.ml_load_model() sont des fonctions réelles et vérifiées, adossées à un registre de modèles en mémoire, indexé par nom et versionné — pas une enveloppe fichier. Chaque sauvegarde sous le même name obtient automatiquement la version suivante ; charger sans version retourne la dernière.

sp.ml_save_model(name, kind, payload, params, metrics, tags) -> dict

Retourne {"name": ..., "version": ...}.

import json
import seraplot as sp

result = sp.knn_classifier(data=X_train, target=y_train, k=5)
saved = sp.ml_save_model(
    name="knn_v1", kind="knn_classifier",
    payload=json.dumps(result), params={"k": "5"}, metrics={}, tags=[],
)
print(saved)  # {'name': 'knn_v1', 'version': 1}

sp.ml_load_model(name, version=None) -> dict

Charge la dernière sauvegarde pour name, ou une version précise si fournie.

loaded = sp.ml_load_model(name="knn_v1")
# {'found': True, 'name': 'knn_v1', 'version': 1, 'kind': 'knn_classifier', 'payload': '...'}

restored = json.loads(loaded["payload"])

Un nom/version absent retourne {"found": False} plutôt que de lever une exception.

Bout-en-bout : entraînement → sauvegarde → recharge

import json
import seraplot as sp

result = sp.knn_classifier(data=X_train, target=y_train, k=5)
sp.ml_save_model(
    name="knn_v1", kind="knn_classifier",
    payload=json.dumps(result), params={"k": "5"}, metrics={}, tags=[],
)

loaded = sp.ml_load_model(name="knn_v1")
restored = json.loads(loaded["payload"])
assert restored == result

Sauvegarder à nouveau sous le même name incrémente la version plutôt que d’écraser :

sp.ml_save_model(name="knn_v1", kind="knn_classifier", payload=json.dumps(result), params={}, metrics={}, tags=[])
# {'name': 'knn_v1', 'version': 2}

sp.ml_load_model(name="knn_v1", version=1)  # la sauvegarde originale existe toujours

Les objets Chart sont sérialisables via __getstate__ / __setstate__ — compatible joblib, multiprocessing, Ray, reruns Streamlit.

Python

import seraplot as sp
import pickle

chart = sp.bar("Revenu", labels=["a", "b", "c"], values=[1, 2, 3])
blob = pickle.dumps(chart)

restored = pickle.loads(blob)
restored.save("restored.html")

En interne, seule la chaîne HTML est sérialisée — payload minimal, aucun état transitoire.

Modèles ML

Les modèles entraînés sont une préoccupation distincte du pickling de Chart — voir ML Model Persistence pour sp.ml_save_model() / sp.ml_load_model().

Injecte les rôles ARIA, <title> et <desc> dans le SVG pour les lecteurs d’écran et la conformité B2B (WCAG 2.1).

Python

import seraplot as sp

chart = (
    sp.bar(labels=["EU","US","APAC"], values=[10,20,30])
      .a11y(title="Revenu trimestriel par région",
            desc="Bar chart, EU 10M, US 20M, APAC 30M")
)

Le SVG résultant inclut role="group" (posé par défaut pour que les points de données et boutons de légende navigables au clavier restent des descendants valides — role="img" interdit tout enfant focusable selon la spec SVG-AAM), plus aria-label, <title>, <desc> ajoutés par .a11y() — reconnus par NVDA, JAWS, VoiceOver.

Les CSP strictes bloquent les <script> inline. La méthode csp_safe() extrait le JS dans un payload <script type="application/json"> + un loader unique compatible nonce.

Python

import seraplot as sp

chart = sp.line(x_labels=["1", "2", "3", "4"], values=[10, 20, 15, 25]).csp_safe()

Applique ta CSP script-src 'nonce-sp-nonce' et le chart se rend toujours.

SeraPlot propose 41 types de graphiques 2D, des barres et courbes basiques aux graphiques spécialisés (ridgeline, haltère, sankey, corde, dendrogramme, venn, corrélogramme, ruche, pulse et orbita).

Signature

sp.bar(title, labels=None, values=None, *, variant="basic", series=None, series_names=None, theme="none", **kwargs) -> Chart

Alias : sp.bar_chart(), sp.bars(), sp.bar_unified(), sp.bars_unified(), sp.bar_family().

Description

sp.bar() est le point d’entrée unifié de la famille de graphiques en barres de SeraPlot. Il génère des graphiques HTML/SVG autonomes depuis Rust. Le mot-clé variant choisit le renderer, et les options communes passent par le pipeline commun.

Le rendu par défaut est un bar chart catégoriel vertical. La même API couvre toutes les variantes bar enregistrées côté Rust.

Variantes

Données

labels sert de liste de catégories pour les variantes bar. Les variantes mono-série utilisent values. Les variantes multi-séries utilisent series, où chaque liste interne est une série, et series_names fournit les noms de légende.

Quand series manque mais que series_names est fourni, values est interprété comme une matrice aplatie découpée par len(labels) : le premier bloc appartient à la première série, le suivant à la deuxième, etc.

Paramètres

Thèmes

Retour

Objet Chart avec une propriété .html et une méthode .show().

Signature

sp.line(title, labels=None, values=None, *, variant="basic", series=None, **kwargs) -> Chart

Description

sp.line() est le point d’entrée unifié pour toute la famille de graphiques en ligne. Le mot-clé variant sélectionne la stratégie de rendu — tous les autres arguments sont partagés entre les variantes.

Variantes

Paramètres

Retourne

Chart — objet avec une propriété .html et une méthode .show().

Signature

sp.area(title, x_labels=None, series=None, *, variant="basic", series_names=None, palette=None, **kwargs) -> Chart

Alias : sp.area, sp.area_chart, sp.area_family, sp.area_unified, sp.build_area_chart

Description

sp.area() est le point d’entrée unifié de toute la famille des graphiques en aires. Le mot-clé variant sélectionne la stratégie de rendu — tous les autres arguments gardent le même nom d’une variante à l’autre. Les graphiques en aires remplissent l’espace entre une courbe et la ligne de base, mettant l’accent sur la magnitude cumulée plutôt que sur la comparaison point à point du graphique en ligne. SeraPlot rend tout en SVG Rust pur, avec superposition multi-séries native, empilement, empilement normalisé à 100%, courbes lissées, interpolation en escalier et remplissages en dégradé.

Variantes

Paramètres

Retour

Chart — objet exposant .html et .show().

Signature

sp.scatter(title, x_values, y_values, *, variant="basic", categories=None, labels=None, color_values=None, **kwargs) -> Chart

Description

sp.scatter() est le point d’entrée unifié de toute la famille scatter. Le mot-clé variant sélectionne la stratégie de rendu — tous les autres arguments gardent le même nom d’une variante à l’autre. Les nuages de points sont la façon canonique d’afficher la distribution conjointe de deux variables numériques ; SeraPlot ajoute groupement optionnel, couleur continue, formes de marqueurs distinctes, étiquettes sur les points et régression OLS — le tout en SVG Rust pur, des milliers de fois plus rapide que Plotly.

Variantes

Paramètres

Retour

Chart — objet exposant .html et .show().

Signature

sp.bubble(title, x_values, y_values, sizes, *, variant="basic", categories=None, labels=None, color_values=None, **kwargs) -> Chart

Description

sp.bubble() est le point d’entrée unique de toute la famille des graphiques à bulles. Le paramètre variant choisit la stratégie de rendu — tous les autres arguments restent cohérents entre variantes. Une bulle représente une troisième dimension via son aire (et non son rayon), pour une lecture perceptive correcte.

Variantes

Paramètres

Retourne

Chart — objet exposant .html et .show().

Signature

sp.histogram(title, values, *, variant="basic", bins=0, overlay_values=None, color_groups=None, series_names=None, **kwargs) -> Chart

Description

sp.histogram() est le point d’entrée unifié de toute la famille histogramme. Le mot-clé variant sélectionne la stratégie de rendu — tous les autres arguments gardent le même nom d’une variante à l’autre. Les histogrammes sont la façon canonique de visualiser la distribution d’une variable numérique ; SeraPlot ajoute layout horizontal, normalisation densité, distribution cumulative, groupes empilés, superposition A/B et contour en escalier — le tout en SVG Rust pur, des milliers de fois plus rapide que Plotly.

Variantes

Paramètres

Thèmes

Passez theme= pour restyliser n’importe quelle variante ci-dessus — les thèmes sont une passe de rendu transversale, pas une variante séparée, et s’appliquent de la même façon sur toutes les familles de graphiques.

Retour

Chart — objet exposant .html et .show().

Signature

sp.heatmap(title, matrix, *, variant="basic", x_labels=None, y_labels=None, **kwargs) -> Chart

Description

sp.heatmap() est le point d’entrée unique pour toute la famille des cartes de chaleur. Le paramètre variant sélectionne la stratégie de rendu — annotée, catégorielle, log, contour, clustering hiérarchique, etc. — tout en partageant la même API de base.

Variantes

Paramètres

Retourne

Chart — objet avec la propriété .html et la méthode .show().

Signature

sp.pie(title, labels=None, values=None, *, variant="basic", **kwargs) -> Chart

Description

sp.pie() est le point d’entrée unique pour toute la famille des camemberts. Le paramètre variant sélectionne la stratégie de rendu — donut, éclaté, KPI, semi-cercle ou imbriqué — tout en conservant la même API simple.

Variantes

Paramètres

Étiquettes flottantes

Passe labeled=True à n’importe quelle variante construite sur le moteur partagé à secteurs angulaires (basic, donut, exploded, kpi, pattern, semi) pour remplacer le texte de pourcentage à l’intérieur du secteur par une étiquette extérieure : une fine ligne de connexion depuis le bord du secteur jusqu’à un label affichant le pourcentage et le nom de catégorie, colorée comme sa part. C’est le même style que les captures “répartition totale” en donut données en référence — ce n’est pas une variante séparée, c’est une option d’affichage que n’importe laquelle de ces variantes peut activer.

import seraplot as sp

c = sp.pie(
    labels=["Acquisition", "Conversion", "Retention", "Referral", "Other"],
    values=[42, 26, 16, 11, 5],
    variant="donut",
    center_text="27.3K",
    center_subtext="TOTAL",
    labeled=True,
)

Retourne

Chart — objet avec la propriété .html et la méthode .show().

Signature

sp.boxplot(title, labels=None, values=None, *, variant="basic", series=None, **kwargs) -> Chart

Description

sp.boxplot() est le point d’entrée unique pour toute la famille des boîtes à moustaches. Le paramètre variant sélectionne la stratégie de rendu — tous les autres arguments restent identiques entre les variantes. Quartiles, moustaches 1,5×IQR et valeurs aberrantes sont calculés en pur Rust, sans NumPy ni pandas.

Variantes

Paramètres

Retourne

Chart — objet avec la propriété .html et la méthode .show().