import seraplot as sp
sp.pulse_status()
# {'state': 'trial', 'days_left': '90'}

sp.scatter(x=x, y=y).push(idx, x, y)
# PermissionError: seraplot pulse: free trial (90 days) has ended.
# Activate a license with sp.pulse_activate(key) to keep using
# push()/serve()/record()/replay()/on_anomaly().

sp.pulse_activate("eyJjIjoi...ZTFhMTki.MEUCIQDx...")
sp.pulse_status()
# {'state': 'licensed', 'customer': '...', 'plan': 'pro', 'expires_at': '...'}

sp.pulse_machine_id()
# 'DESKTOP-ABC123-alice-...'

import seraplot as sp

key = sp.SeraKey.generate()
frame = sp.SecureDFrame({"x": x_values, "y": y_values}, key.to_bytes())
chart_data = frame.to_chart_data("x", "y", key.to_bytes(), max_points=2000)

import seraplot as sp

chart = sp.bar("Sales", labels=["Q1", "Q2", "Q3"], values=[120, 150, 90])
chart.export_pdf("sales.pdf")
chart.export_docx("sales.docx")

chart.export_pdf("sales.pdf", interactive=False)
sp.export_pdf_report(charts, "quarterly_report.pdf", titles=titles, interactive=True)

import seraplot as sp

bar = sp.bar("Quarterly Sales", labels=["Q1", "Q2", "Q3", "Q4"], values=[120, 150, 90, 175], color_hex=0x3B82F6).show_grid().despine()
line = sp.line("Daily Active Users", x_labels=["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"], values=[820, 932, 901, 934, 1290, 1330, 1320], color_hex=0x22C55E).show_grid().despine()
scatter = sp.scatter("Latency vs Load", x=[10, 20, 30, 40, 50, 60, 70, 80], y=[12, 18, 22, 35, 40, 55, 61, 78], variant="regression").show_grid().despine()
pie = sp.pie("Traffic Sources", labels=["Organic", "Paid", "Referral", "Direct"], values=[45, 25, 15, 15])
boxplot = sp.boxplot("Response Time by Region", labels=["US"] * 6 + ["EU"] * 6 + ["APAC"] * 6, values=[120, 130, 125, 118, 140, 122, 200, 210, 195, 205, 220, 198, 90, 95, 88, 102, 97, 91])
heatmap = sp.heatmap("Weekly Activity", labels=["Mon", "Tue", "Wed", "Thu", "Fri"], col_labels=["8h", "12h", "16h", "20h"], values=[5, 9, 7, 3, 6, 12, 10, 4, 8, 15, 13, 7, 4, 8, 11, 5, 3, 7, 9, 2])

charts = [bar, line, scatter, pie, boxplot, heatmap]
titles = ["Quarterly Sales", "Daily Active Users", "Latency vs Load", "Traffic Sources", "Response Time by Region", "Weekly Activity"]
sp.export_pdf_report(charts, "quarterly_report.pdf", titles=titles)

import seraplot as sp

chart = sp.firehose("CPU %", capacity=2_000, min_val=0.0, max_val=100.0)
chart.serve(port=8787)
for reading in sensor_stream():
    chart.firehose_push([reading])

import random
import seraplot as sp

chart = sp.firehose("Live sensor feed", capacity=300, min_val=0.0, max_val=100.0, height=260)
chart.record("session.spls")
value = 50.0
for _ in range(1_200):
    value = max(0.0, min(100.0, value + random.uniform(-2.5, 2.5)))
    chart.firehose_push([value])
chart.stop_record()
chart.export_standalone("firehose-demo.html", "session.spls")

import seraplot as sp

chart = sp.bar("Error rate by region", labels=["us-east", "eu-west", "ap-south"], values=[12, 4, 31])
chart.record("incident.spls")
chart.serve(port=8787)

chart.serve(port=8787, collab=False)

import seraplot as sp

errors = sp.bar("Error rate", labels=["us-east", "eu-west", "ap-south"], values=[12, 4, 31])
latency = sp.line("p99 latency (ms)", x=list(range(20)), y=[120, 118, 125, 400, 410, 190, 130, 128, 126, 124, 122, 400, 405, 190, 128, 126, 124, 122, 120, 118])
queue = sp.scatter("Queue depth", x=list(range(30)), y=[3, 5, 4, 40, 38, 6, 5, 4, 3, 4] * 3)

sp.serve_board([errors, latency, queue], titles=["Errors", "Latency", "Queue"], session="2026-08-09", port=8787)

errors.serve(port=8788)
sp.serve_board([errors, latency, queue], titles=["Errors", "Latency", "Queue"], live_urls=[f"http://127.0.0.1:8788", None, None], session="2026-08-09", port=8787)

sp.export_board_html([errors, latency, queue], "war_room.html", titles=["Errors", "Latency", "Queue"])

import seraplot as sp

chart = sp.bar("Sensors", labels=[str(i) for i in range(600)], values=[10.0] * 600)
chart.record("session.spls")
chart.push([3], [14.5])
chart.push([3], [16.0])
chart.stop_record()
chart.export_gif("session.gif", "session.spls")

chart.record("session.spls")
chart.push([3], [14.5])
chart.push([3], [16.0])
chart.stop_record()
chart.export_video("session.mp4", "session.spls", format="mp4", fps=30, sort_by_value=True)

chart.export_video("session_smooth.mp4", "session.spls", format="mp4", fps=60, sort_by_value=True, smooth=True, smooth_speed=1.5, smooth_ease="ease_in_out")

chart.export_video("reveal.mp4", "session.spls", format="mp4", fps=30, reveal=True, reveal_steps=150)

chart.export_video(
    "paused.mp4", "session.spls", format="mp4", fps=30,
    reveal=True, reveal_steps=150,
    breakpoint_at_ms=[2500], breakpoint_on_value=[(3, 90.0)], breakpoint_pause_ms=1200,
)

Sera Pulse est la couche de streaming au-dessus de chaque chart natif : .push(), .push_vector(), .serve(), .record(), .replay(), .on_anomaly(). Le rendu lui-même (sp.scatter(), sp.bar(), sp.heatmap(), sp.candlestick(), et tout autre chart natif à chemin rapide) reste gratuit et open-source — Pulse ne verrouille que la couche de mise à jour incrémentale construite par-dessus.

Ce qui est inclus

Tout ce qui suit est sous une seule et même porte — le même essai actif ou la même licence débloque tout, Solo comme Team (Team n’ajoute que des postes et du support prioritaire, pas de fonctionnalités en plus) :

• Streaming — push(), push_vector(), serve(), record()/replay(), on_anomaly(), export_standalone().
• Sera Firehose — sp.firehose(...) + firehose_push(), un chart à tampon circulaire pour les flux très haute fréquence, rendu via WebGL2.
• Sera Live — curseurs en direct, commentaires épinglés, un « replay together » partagé sur tout chart .serve(), et un thème clair/sombre commutable en un clic.
• Sera Board — serve_board()/export_board_html(), un tableau blanc infini façon Figma : cadres de charts déplaçables/zoomables, épingles, dessins à main levée, images déposées, tout en direct et collaboratif et sauvegardé dans une session persistante qu’on change en un clic, ou exporté en fichier statique.
• Sera Secure — SeraDFrame, chiffrement AES-256-GCM à l’entrée, le texte en clair n’est jamais mis en cache ni journalisé.
• SeraReport — export_pdf(), export_docx(), export_pdf_report(), chacun avec un lien compagnon interactif optionnel.
• SeraStudio — export_video(), export_gif(), enregistrement/relecture de session pour des extraits de chart partageables.

Chaque méthode ci-dessus appelle la même vérification de licence — une clé s’active sur une seule machine, et chaque prix ci-dessous est fixé pour de bon : les nouvelles fonctionnalités payantes rejoignent ce même catalogue sans coût supplémentaire, elles ne passent jamais derrière un nouveau palier.

---

Essai gratuit

La première fois qu’une méthode Pulse est appelée sur une machine, un essai de 90 jours (3 mois) démarre automatiquement — sans carte, sans inscription, sans appel réseau. Visible via :

import seraplot as sp
sp.pulse_status()
# {'state': 'trial', 'days_left': '90'}

Tout (push, push_vector, serve, record, replay, on_anomaly) fonctionne exactement comme avec une licence payante pendant l’essai — aucune différence de fonctionnalité, seulement une limite de temps.

---

Après l’essai

Une fois les 90 jours écoulés, les méthodes Pulse lèvent une PermissionError claire renvoyant vers l’activation plutôt que d’échouer silencieusement ou de se dégrader :

sp.scatter(x=x, y=y).push(idx, x, y)
# PermissionError: seraplot pulse: free trial (90 days) has ended.
# Activate a license with sp.pulse_activate(key) to keep using
# push()/serve()/record()/replay()/on_anomaly().

Activez avec la clé reçue après achat :

sp.pulse_activate("eyJjIjoi...ZTFhMTki.MEUCIQDx...")
sp.pulse_status()
# {'state': 'licensed', 'customer': '...', 'plan': 'pro', 'expires_at': '...'}

Une clé de licence est un jeton auto-suffisant signé cryptographiquement — l’activation fonctionne entièrement hors ligne, sans phone-home, sans télémétrie.

Les plans verrouillés à une machine (voir Solo ci-dessous) sont liés à un identifiant local plutôt que librement copiables d’un ordinateur à l’autre :

sp.pulse_machine_id()
# 'DESKTOP-ABC123-alice-...'

Envoyez cet identifiant lors de l’achat d’une clé verrouillée à une machine — il est embarqué dans la licence signée et vérifié à l’activation.

---

Formules

Payé via PayPal — cliquez un lien d’achat, payez sur la page de paiement hébergée par PayPal, et votre clé de licence est générée automatiquement dès que le paiement est confirmé : un webhook signé déclenche la génération, vérifié contre la signature de PayPal pour qu’il soit impossible de simuler un paiement. Préférence pour la crypto (USDC/Polygon, auto-hébergé) ou une vente manuelle ? Passez par le canal de support.

Ce prix est fixé pour de bon : chaque fonctionnalité payante que ce catalogue gagnera plus tard — Sera Firehose, Sera Secure, SeraReport, SeraStudio, ce qui sortira ensuite — rejoint le même prix Solo/Team ci-dessus sans coût supplémentaire. Il n’y a pas de palier supérieur caché derrière un mur de paiement.

Chaque clé s’active sur une seule machine — toujours. Team n’est pas une clé multi-postes partagée, c’est une clé équivalente à Solo par membre de l’équipe, chacune verrouillée à la machine de ce membre, facturées ensemble.

Saisissez n’importe quel nombre de postes et n’importe quel nombre de mois (1 à 36) — le lien facture le taux plein par poste et par mois multiplié par ce nombre de postes et de mois, sauf exactement 12 mois qui utilise le tarif annuel réduit indiqué ci-dessus (même tarif que vous tapiez 12 ici ou passiez par un forfait annuel ailleurs — jamais de prix caché ou différent). Même principe pour Solo : .../paypal/buy/solo/<mois>?seats=<postes>.

Renouveler une clé existante garde son identité client et son verrouillage machine, et repousse juste l’expiration — c’est en réalité un nouveau jeton signé sous le capot (une signature ne se modifie pas après coup), mais même client, même machine, même appel sp.pulse_activate() de votre côté. Prenez votre clé actuelle et placez-la dans https://sera-payment.onrender.com/paypal/renew/solo/monthly?key=<votre clé> (remplacez solo/monthly par votre vrai plan/période ; marche aussi pour team, une clé de poste à la fois).

---

Sera Secure

SecureDFrame/SecureDFrameBuilder/SeraKey sont les équivalents chiffrés en AES-256-GCM de SeraDFrame — les colonnes restent en texte chiffré en mémoire, déchiffrées seulement de façon transitoire pour une lecture ou un rendu de chart ponctuel. Ils font partie du même catalogue payant que les méthodes de streaming ci-dessus et partagent le même essai/licence — pas d’achat séparé, pas d’activation séparée :

import seraplot as sp

key = sp.SeraKey.generate()
frame = sp.SecureDFrame({"x": x_values, "y": y_values}, key.to_bytes())
chart_data = frame.to_chart_data("x", "y", key.to_bytes(), max_points=2000)

Comment c’est organisé

Pourquoi les équipes s’en servent

Un dump de process, un fichier core égaré, un débogueur attaché au mauvais moment — avec un SeraDFrame normal, c’est toute la colonne, en clair. Avec SecureDFrame, c’est du texte chiffré, un point c’est tout. La fenêtre en clair se limite exactement à une lecture : to_chart_data() déchiffre, le chart se rend, et il ne reste rien en mémoire qui puisse fuiter. Si vous affichez des dossiers patients, un historique de transactions, des données personnelles, ou tout ce que vous préféreriez ne pas avoir à expliquer à un responsable conformité après coup, c’est le changement d’une ligne (SeraDFrame → SecureDFrame) qui fait la différence entre « on a eu une fuite mémoire » et « on a eu un incident ».

Ça ne coûte rien de plus à essayer — c’est le même essai et la même licence que toutes les autres fonctionnalités Pulse de cette page, donc aucune décision d’achat séparée à prendre. Démarrez l’essai gratuit et changez un nom de classe.

---

SeraReport

export_pdf() convertit le SVG propre au chart directement en PDF vectoriel natif — sans navigateur headless, sans capture d’écran, juste une conversion SVG-vers-PDF directe. export_docx() fait pareil vers un document Word, le chart intégré en vraie image. Même catalogue, même essai/licence que le reste de cette page :

import seraplot as sp

chart = sp.bar("Ventes", labels=["Q1", "Q2", "Q3"], values=[120, 150, 90])
chart.export_pdf("ventes.pdf")
chart.export_docx("ventes.docx")

Nécessite que le chart ait un vrai contenu SVG — les charts assez grands pour dépasser leur seuil de rendu canvas natif se rendent via <canvas> plutôt que <svg> (la même limite qu’ont déjà export_svg()/export_png()). export_pdf_report(charts, path, titles=None) combine plusieurs charts en un seul PDF multi-page, une page chacun.

Les deux méthodes prennent un paramètre interactive, vrai par défaut : en plus du PDF/DOCX, un fichier .html compagnon est écrit à côté — la vraie page interactive du chart — et un lien cliquable est intégré dans le document (une annotation de lien /GoToR dans le PDF, un paragraphe hyperlien dans le DOCX) qui l’ouvre. Passez interactive=False pour un simple fichier statique sans compagnon :

chart.export_pdf("ventes.pdf", interactive=False)
sp.export_pdf_report(charts, "rapport_trimestriel.pdf", titles=titres, interactive=True)

Exemple complet

export_pdf() est une conversion 1:1 directe — la page PDF vectorielle est exactement le SVG du chart, rien n’est re-rendu ni rastérisé entre les deux. export_pdf_report() fait pareil pour tout un ensemble de charts d’un coup, une vraie page par chart. Le PDF ci-dessous a été généré par le script juste en dessous — six familles de charts différentes (bar, line, scatter, pie, boxplot, heatmap), un seul rapport multi-page, ouvrez-le directement ici :

import seraplot as sp

bar = sp.bar("Ventes trimestrielles", labels=["Q1", "Q2", "Q3", "Q4"], values=[120, 150, 90, 175], color_hex=0x3B82F6).show_grid().despine()
line = sp.line("Utilisateurs actifs quotidiens", x_labels=["Lun", "Mar", "Mer", "Jeu", "Ven", "Sam", "Dim"], values=[820, 932, 901, 934, 1290, 1330, 1320], color_hex=0x22C55E).show_grid().despine()
scatter = sp.scatter("Latence vs Charge", x=[10, 20, 30, 40, 50, 60, 70, 80], y=[12, 18, 22, 35, 40, 55, 61, 78], variant="regression").show_grid().despine()
pie = sp.pie("Sources de trafic", labels=["Organique", "Payant", "Référent", "Direct"], values=[45, 25, 15, 15])
boxplot = sp.boxplot("Temps de réponse par région", labels=["US"] * 6 + ["EU"] * 6 + ["APAC"] * 6, values=[120, 130, 125, 118, 140, 122, 200, 210, 195, 205, 220, 198, 90, 95, 88, 102, 97, 91])
heatmap = sp.heatmap("Activité hebdomadaire", labels=["Lun", "Mar", "Mer", "Jeu", "Ven"], col_labels=["8h", "12h", "16h", "20h"], values=[5, 9, 7, 3, 6, 12, 10, 4, 8, 15, 13, 7, 4, 8, 11, 5, 3, 7, 9, 2])

charts = [bar, line, scatter, pie, boxplot, heatmap]
titres = ["Ventes trimestrielles", "Utilisateurs actifs quotidiens", "Latence vs Charge", "Sources de trafic", "Temps de réponse par région", "Activité hebdomadaire"]
sp.export_pdf_report(charts, "rapport_trimestriel.pdf", titles=titres)

---

Sera Firehose

sp.firehose(...) est un chart construit pour une seule chose : absorber un flux très rapide de valeurs — capteurs, prix, latences de requêtes — sans que l’onglet du navigateur s’étouffe dessus. C’est un tampon circulaire de taille fixe, côté serveur comme navigateur : vous ne suivez jamais de position d’écriture, vous ne faites jamais grossir un tableau indéfiniment. Une fois le tampon plein, chaque nouvelle valeur écrase silencieusement la plus ancienne.

import seraplot as sp

chart = sp.firehose("CPU %", capacity=2_000, min_val=0.0, max_val=100.0)
chart.serve(port=8787)
for reading in flux_capteur():
    chart.firehose_push([reading])

firehose_push() est push() avec les indices calculés pour vous — même limitation de débit, même détection d’anomalies via on_anomaly(), même record()/replay(), même diffusion .serve() sur les mêmes trames WebSocket binaires que tout autre chart natif diffuse déjà. Rien de nouveau côté transport ; ce qui est nouveau c’est le client : au lieu d’un <canvas> redessiné point par point sur le CPU, Firehose se rend via WebGL2 — un envoi de buffer GPU par frame d’animation, un seul appel drawArrays, aucun travail JavaScript par point quel que soit le nombre de valeurs arrivées depuis la dernière frame, dans tous les navigateurs actuels sans rien à installer en plus.

Le tampon circulaire lui-même est un type Rust générique et réellement réutilisable (RingBuffer<T>), pas un bricolage ponctuel : capacité fixe, aucune réallocation une fois construit, écrasement du plus ancien à chaque ajout. En build release il tient plus de 200 millions d’ajouts par seconde en pure gestion de tampon — le vrai plafond pour 100k+ valeurs/seconde, c’est le coût d’appel Python et le réseau, jamais le tampon.

Aperçu en direct

C’est le vrai chart, en train de vraiment se dessiner — pas une capture d’écran. Un petit générateur synthétique tourne entièrement dans votre navigateur, en appelant exactement la même fonction sp_apply_<id> dans laquelle firehose_push() streame :

import random
import seraplot as sp

chart = sp.firehose("Flux capteur en direct", capacity=300, min_val=0.0, max_val=100.0, height=260)
chart.record("session.spls")
valeur = 50.0
for _ in range(1_200):
    valeur = max(0.0, min(100.0, valeur + random.uniform(-2.5, 2.5)))
    chart.firehose_push([valeur])
chart.stop_record()
chart.export_standalone("firehose-demo.html", "session.spls")

L’aperçu ci-dessus utilise un petit générateur en boucle plutôt qu’un enregistrement fini pour ne jamais tomber à court de données sur cette page, mais il appelle exactement la même fonction sp_apply_<id> dans les deux cas — export_standalone() est la vraie méthode, officielle, pour livrer une démo autonome comme celle-ci.

---

Sera Live

Un partage d’écran, c’est la fenêtre d’une seule personne, à la position de scroll d’une seule personne, décrite à voix haute à tous les autres qui plissent les yeux devant un flux qui rame. Sera Live transforme n’importe quel chart .serve() en vraie salle partagée : tout le monde qui ouvre le lien est dans le chart ensemble, en pleine résolution, sur son propre écran.

import seraplot as sp

chart = sp.bar("Taux d'erreur par région", labels=["us-east", "eu-west", "ap-south"], values=[12, 4, 31])
chart.record("incident.spls")
chart.serve(port=8787)

Envoyez ce lien et tous les curseurs de la salle bougent en direct, en temps réel, nommés et colorés par personne. Épinglez une note directement sur la barre qui explose et elle apparaît pour tout le monde instantanément — pas un commentaire trois scrolls plus bas dans un fil, une étiquette posée exactement là où est le problème. Entourez-la, soulignez-la, dessinez une flèche vers ce que tout le monde doit regarder, à main levée, dans la couleur qui fait passer le message. Cliquez sur « Replay together » et chaque onglet connecté traverse l’incident enregistré au même rythme, ensemble, au lieu que cinq personnes reconstituent la même chronologie de cinq façons différentes. Un clic bascule toute la salle dans un thème sombre pensé pour un écran mural ou une war room à 2h du matin, mémorisé par navigateur. Rejoignez avec quatre minutes de retard et vous n’avez rien raté — chaque épingle et chaque trait posés avant votre connexion vous sont rejoués dès que vous arrivez.

Rien de tout ça n’est un système à part greffé par-dessus : curseurs, épingles, dessins et rejeu voyagent tous sur le même WebSocket que .serve() ouvre déjà. Les épingles sont de vraies annotations bookmark(), pas une couche jetable — listez-les ensuite avec chart.bookmarks() comme d’habitude. Besoin de l’ancien comportement mono-spectateur, où rien concernant vous ou votre curseur ne quitte jamais votre machine ? collab=False désactive tout ça :

chart.serve(port=8787, collab=False)

Fermer un onglet retire ce curseur pour tout le monde immédiatement — une fenêtre de 15 secondes ne sert qu’à rattraper un vrai crash, jamais une fermeture normale. Les épingles et le rejeu partagent la même limitation de débit que le flux de données lui-même, donc un script errant — ou deux personnes qui cliquent Replay au même instant — ne peuvent pas inonder la salle. username/password gardent un lien privé, exactement comme pour le flux sous-jacent.

---

Sera Board

Un chart à la fois, ça suffit pour une seule métrique. Un vrai incident, jamais — taux d’erreur, latence, profondeur de file, marqueurs de déploiement, liés mais rarement de la même forme, et normalement éparpillés sur cinq onglets que personne ne peut voir en même temps. Sera Board pose tous les charts sur une seule toile infinie à la place : une barre latérale les liste tous, chacun dans son propre cadre qu’on déplace où on veut, et on zoome d’une vue commandement complète jusqu’à un seul chart plein écran.

serve_board() réunit Sera Board et Sera Live — la même salle partagée, les mêmes curseurs en direct, désormais sur toute une toile plutôt qu’un seul chart :

import seraplot as sp

erreurs = sp.bar("Taux d'erreur", labels=["us-east", "eu-west", "ap-south"], values=[12, 4, 31])
latence = sp.line("Latence p99 (ms)", x=list(range(20)), y=[120, 118, 125, 400, 410, 190, 130, 128, 126, 124, 122, 400, 405, 190, 128, 126, 124, 122, 120, 118])
file_attente = sp.scatter("Profondeur de file", x=list(range(30)), y=[3, 5, 4, 40, 38, 6, 5, 4, 3, 4] * 3)

sp.serve_board([erreurs, latence, file_attente], titles=["Erreurs", "Latence", "File"], session="2026-08-09", port=8787)

Envoyez ce lien à l’équipe. Épinglez un commentaire, déposez une capture d’écran directement depuis le bureau, ou dessinez sur un chart — ça se colle au cadre de ce chart, déplacez le cadre et l’annotation suit. Regroupez les charts qui racontent la même histoire et déplacez tout le bloc ensemble ; chaque mouvement est partagé en direct et sauvegardé, donc la disposition dans laquelle l’équipe laisse la salle est celle qu’elle retrouve la fois suivante. Survolez n’importe quel cadre et ses propres infobulles s’activent directement, sur place — la toile ne se dispute jamais la souris avec un chart.

Tout — épingles, dessins, images, disposition — vit dans une session nommée sur disque, restaurée automatiquement la prochaine fois que cette session est servie : fermez le serveur, rouvrez-le une semaine plus tard, la salle est exactement où elle était. Basculez toute la salle vers une autre session sauvegardée en un clic, en direct, sans recharger et sans nouveau lien — tout le monde connecté bascule ensemble. Besoin qu’un cadre précis streame de vraies données en direct plutôt qu’un instantané figé pendant que les autres restent statiques ? Pointez live_urls dessus :

erreurs.serve(port=8788)
sp.serve_board([erreurs, latence, file_attente], titles=["Erreurs", "Latence", "File"], live_urls=[f"http://127.0.0.1:8788", None, None], session="2026-08-09", port=8787)

Ce cadre reçoit un petit point vert qui pulse et streame pour de vrai, en continu ; les deux autres restent des instantanés statiques.

Pas besoin que ce soit en direct — juste un fichier à envoyer ? export_board_html() écrit la même toile en un seul .html autonome, sans serveur : même disposition glisser-zoomer, chaque chart garde son propre survol et ses infobulles dans son cadre.

sp.export_board_html([erreurs, latence, file_attente], "war_room.html", titles=["Erreurs", "Latence", "File"])

La présence (curseurs) est propre à toute la toile plutôt qu’à chaque chart — chaque chart intégré est son propre <iframe> isolé, donc un cadre purement statique ne peut pas streamer par lui-même ; c’est exactement à ça que sert live_urls. Une épingle supprimée de la toile disparaît de la vue en direct et de la session sauvegardée, mais pas de chart.bookmarks() si ce chart garde aussi ses propres repères persistants — la couche de la toile et l’enregistrement permanent d’un chart restent volontairement indépendants. La toile en direct et l’export statique tournent tous deux sur le même catalogue et la même licence que le reste de cette page.

---

SeraStudio

chart.export_gif(gif_path, spls_path) rend un enregistrement .spls (issu de record()) en GIF animé — une frame par mise à jour enregistrée, en ne dessinant un emplacement que pour les indices réellement poussés pendant l’enregistrement, pour qu’observer quelques valeurs évoluer au sein d’un chart bien plus grand produise quand même une animation lisible. Même catalogue, même essai/licence que le reste de cette page :

import seraplot as sp

chart = sp.bar("Capteurs", labels=[str(i) for i in range(600)], values=[10.0] * 600)
chart.record("session.spls")
chart.push([3], [14.5])
chart.push([3], [16.0])
chart.stop_record()
chart.export_gif("session.gif", "session.spls")

Quand l’enregistrement porte sa source de construction d’origine (vrai pour tout .spls enregistré depuis le format v4 avec source), chaque frame est rejouée via le vrai rendu de cette famille de chart — une heatmap themée montre sa vraie grille de couleurs, une barre variant="pictogram" montre de vraies icônes — plutôt qu’un substitut générique. Les enregistrements issus d’anciens fichiers .spls, ou des familles sans correspondance de rejeu, retombent automatiquement sur un rendu basé uniquement sur la forme des données poussées (une valeur par indice, une paire x/y, ou un vecteur à N valeurs) : les enregistrements bar/heatmap se rendent en barres de magnitude, les enregistrements scatter/ligne/bulle/aire se rendent en point mobile par indice, et les enregistrements vecteur à 4 valeurs se rendent en vrais chandeliers OHLC (vert/rouge pour hausse/baisse ; les autres largeurs de vecteur retombent sur des mini-barres groupées) — pour ne jamais échouer completement, même sans correspondance de rejeu. color=(r, g, b) personnalise la couleur de ce rendu de secours (ignorée dès qu’un rejeu fidèle à la famille rend la frame). sort_by_value=True reclasse les emplacements par valeur courante à chaque frame pour un effet « bar chart race », en compactant la frame sur les seules lignes en course et en emportant le vrai libellé de chaque ligne avec elle quand elle change de rang. chart.gif_frame_count(spls_path) consulte le nombre de frames d’un enregistrement sans rien rendre ; chart.gif_preview_frame(spls_path, frame_index, png_path) rend une seule frame en PNG. Alias : to_gif/save_gif pour export_gif, gif_length pour gif_frame_count.

Pour un vrai fichier vidéo plutôt qu’un GIF, chart.export_video(video_path, spls_path, format="mp4") rend la même visualisation fidèle à la famille quand elle est disponible, via un vrai codec vidéo (ffmpeg doit être installé et accessible sur le PATH) à un frame rate constant — les rafales de mises à jour rapides se compressent sur le dernier état, les silences répètent la dernière frame connue, donc la vitesse de lecture correspond toujours à ce qui s’est réellement passé :

chart.record("session.spls")
chart.push([3], [14.5])
chart.push([3], [16.0])
chart.stop_record()
chart.export_video("session.mp4", "session.spls", format="mp4", fps=30, sort_by_value=True)

format est un parmi "mp4" (H.264, largement compatible), "webm" (VP9, plus léger/natif web), "mov", "mkv", ou "avi" — avec un raccourci par format (export_mp4, export_webm, export_mov, export_mkv, export_avi), plus les alias to_video/save_video pour export_video lui-même.

export_gif() et export_video() (ainsi que gif_preview_frame()) acceptent aussi smooth=True : au lieu de sauter directement à chaque état enregistré, la géométrie des éléments correspondants est animée entre deux états enregistrés consécutifs — mis en correspondance par l’identité réelle de chaque ligne, pas son emplacement à l’écran, pour qu’une ligne en course garde sa propre animation même quand sort_by_value réassigne les emplacements autour d’elle. Les valeurs évoluent en douceur, et une ligne en course glisse visiblement devant les autres en les dépassant, plutôt que de se téléporter à son nouveau rang à la frame suivante. smooth_speed (défaut 1.0) ajuste le nombre d’étapes intermédiaires d’une transition — 2.0 est deux fois plus rapide avec moins d’étapes, 0.5 est deux fois plus lent avec plus d’étapes ; smooth_ease (défaut "linear") choisit la courbe de rythme parmi "linear", "ease_in", "ease_out", "ease_in_out" :

chart.export_video("session_smooth.mp4", "session.spls", format="mp4", fps=60, sort_by_value=True, smooth=True, smooth_speed=1.5, smooth_ease="ease_in_out")

smooth est optionnel et désactivé par défaut — il coûte un temps de rendu supplémentaire par transition (chaque étape interpolée rastérise quand même une frame complète), donc utile pour un export soigné destiné à une présentation, mais pas nécessaire pour un aperçu rapide. Il n’a aucun effet sans source de rejeu disponible (fichier .spls pré-v4, ou famille sans correspondance de rejeu) : ceux-là retombent toujours sur le rendu basé sur la forme des données, sans changement.

Pour un jeu de données connu et complet plutôt qu’un flux temps réel, reveal=True remplace entièrement la vraie ligne de temps de mises à jour : au lieu de rejouer les vrais événements de push de l’enregistrement, il révèle l’état final touché progressivement dans l’ordre des indices sur reveal_steps frames, comme si le chart se dessinait lui-même — une courbe ou un jeu de barres qui apparaît point par point plutôt que de sauter entre états enregistrés. Le rythme utilise le même smooth_tick_ms que celui déjà dérivé du fps de l’export, donc reveal_steps frames à un fps donné prennent reveal_steps / fps secondes, peu importe le vrai timing de l’enregistrement .spls sous-jacent :

chart.export_video("reveal.mp4", "session.spls", format="mp4", fps=30, reveal=True, reveal_steps=150)

breakpoint_at_ms et breakpoint_on_value maintiennent chacun la sortie sur une frame pendant breakpoint_pause_ms la première fois qu’une condition est atteinte — breakpoint_at_ms sur le temps écoulé en sortie, breakpoint_on_value (sous forme de paires (indice, seuil)) la première fois que la valeur décodée d’un indice suivi spécifique atteint ou dépasse un seuil. Chaque frame suivante est décalée en avant de la durée de la pause pour garder le reste de la ligne de temps intact ; chaque breakpoint se déclenche une seule fois. Les deux se combinent aussi bien avec reveal qu’avec la lecture normale/smooth, puisqu’ils opèrent sur la ligne de temps de frames déjà construite, quelle qu’elle soit :

chart.export_video(
    "paused.mp4", "session.spls", format="mp4", fps=30,
    reveal=True, reveal_steps=150,
    breakpoint_at_ms=[2500], breakpoint_on_value=[(3, 90.0)], breakpoint_pause_ms=1200,
)

Vitrines vidéo

Sept exports réels, générés par les scripts affichés sous chacun — cliquez sur « Voir le code » pour lire le .py exact qui l’a produit.

Catalogue complet

Toutes les familles et variants de charts enregistrés, lus en direct depuis le même registre qui alimente la Vitrine — recherchez, puis cliquez sur « Voir le code » pour obtenir un extrait SeraStudio record() / push() / export_video() prêt à l’emploi, construit à partir des vrais paramètres de construction de ce variant. Toutes les familles ne supportent pas encore push() (voir les paragraphes SeraStudio ci-dessus) — l’extrait généré montre quand même la bonne forme à compléter.

Parcourir le catalogue complet

---

Référence des méthodes

Toujours synchronisé avec l’implémentation réelle. Utilisez les onglets ci-dessous pour aller directement à un mini-module (streaming, détection d’anomalies, alertes, repères, push distant, limitation de débit, historique/rapports, santé, licence, Sera Secure, SeraReport, SeraStudio) plutôt que de parcourir la liste complète.