grimoireplot 0.0.1__py3-none-any.whl

grimoireplot/main.py

@@ -0,0 +1,284 @@
+# SPDX-FileCopyrightText: Copyright © 2026 Idiap Research Institute <contact@idiap.ch>
+# SPDX-FileContributor: William Droz <william.droz@idiap.ch>
+# SPDX-License-Identifier: MIT
+
+"""
+Main CLI for GrimoirePlot application.
+"""
+
+import argparse
+from grimoireplot.common import get_grimoire_secret, get_grimoire_server
+
+
+def serve_command(args):
+    """Run the GrimoirePlot server."""
+    from grimoireplot.server import my_app
+
+    my_app(host=args.host, port=args.port)
+
+
+def live_test_command(args):
+    """Run a live test that adds one datapoint every 0.2 seconds to two plots."""
+    import time
+    import math
+    import plotly.graph_objects as go
+    from grimoireplot.client import push_plot_sync
+
+    server_url = f"http://{args.host}:{args.port}"
+    grimoire_name = args.grimoire_name
+    chapter_name = "Live Test"
+
+    print(f"Starting live test to {server_url}")
+    print(f"Grimoire: {grimoire_name}")
+    print(f"Adding one datapoint every {args.interval} seconds to 2 plots")
+    print("Press Ctrl+C to stop")
+    print("-" * 40)
+
+    # Data for plot 1 (sine wave)
+    x_data_1 = []
+    y_data_1 = []
+    # Data for plot 2 (cosine wave)
+    x_data_2 = []
+    y_data_2 = []
+    step = 0
+
+    try:
+        while args.max_points == 0 or step < args.max_points:
+            # Generate new datapoints
+            x_data_1.append(step)
+            y_data_1.append(math.sin(step * 0.1) + (step * 0.01))
+            x_data_2.append(step)
+            y_data_2.append(math.cos(step * 0.1) + (step * 0.01))
+
+            # Create figure 1 (sine wave)
+            fig1 = go.Figure()
+            fig1.add_trace(
+                go.Scatter(
+                    x=x_data_1,
+                    y=y_data_1,
+                    mode="lines+markers",
+                    name="Sine Wave",
+                    line=dict(color="blue"),
+                    marker=dict(size=6),
+                )
+            )
+            fig1.update_layout(
+                title=f"Sine Wave (Point {step + 1})",
+                xaxis_title="Step",
+                yaxis_title="Value",
+            )
+
+            # Create figure 2 (cosine wave)
+            fig2 = go.Figure()
+            fig2.add_trace(
+                go.Scatter(
+                    x=x_data_2,
+                    y=y_data_2,
+                    mode="lines+markers",
+                    name="Cosine Wave",
+                    line=dict(color="red"),
+                    marker=dict(size=6),
+                )
+            )
+            fig2.update_layout(
+                title=f"Cosine Wave (Point {step + 1})",
+                xaxis_title="Step",
+                yaxis_title="Value",
+            )
+
+            # Push both plots to server
+            try:
+                push_plot_sync(
+                    grimoire_name=grimoire_name,
+                    chapter_name=chapter_name,
+                    plot_name="Sine Wave",
+                    fig=fig1,
+                    grimoire_secret=args.secret,
+                    grimoire_server=server_url,
+                )
+                push_plot_sync(
+                    grimoire_name=grimoire_name,
+                    chapter_name=chapter_name,
+                    plot_name="Cosine Wave",
+                    fig=fig2,
+                    grimoire_secret=args.secret,
+                    grimoire_server=server_url,
+                )
+                print(
+                    f"  Point {step + 1}: sin={y_data_1[-1]:.4f}, cos={y_data_2[-1]:.4f}"
+                )
+            except Exception as e:
+                print(f"  [ERROR] Failed to push point {step + 1}: {e}")
+
+            step += 1
+            time.sleep(args.interval)
+
+    except KeyboardInterrupt:
+        print("\n" + "-" * 40)
+        print(f"Stopped after {step} points")
+
+    print("Done!")
+
+
+def push_samples_command(args):
+    """Push sample plots to test the server."""
+    from grimoireplot.client import push_plot_sync
+    from grimoireplot.create_some_plots import (
+        create_sample_line_plot,
+        create_sample_bar_plot,
+        create_sample_scatter_plot,
+        create_sample_histogram,
+        create_sample_pie_chart,
+        create_sample_box_plot,
+        create_sample_heatmap,
+        create_sample_area_plot,
+    )
+
+    server_url = f"http://{args.host}:{args.port}"
+    grimoire_name = args.grimoire_name
+
+    samples = [
+        ("Basic Plots", "Line Plot", create_sample_line_plot),
+        ("Basic Plots", "Bar Plot", create_sample_bar_plot),
+        ("Basic Plots", "Area Plot", create_sample_area_plot),
+        ("Distributions", "Scatter Plot", create_sample_scatter_plot),
+        ("Distributions", "Histogram", create_sample_histogram),
+        ("Distributions", "Box Plot", create_sample_box_plot),
+        ("Categories", "Pie Chart", create_sample_pie_chart),
+        ("Categories", "Heatmap", create_sample_heatmap),
+    ]
+
+    print(f"Pushing {len(samples)} sample plots to {server_url}")
+    print(f"Grimoire: {grimoire_name}")
+    print("-" * 40)
+
+    for chapter, plot_name, create_func in samples:
+        try:
+            fig = create_func()
+            _ = push_plot_sync(
+                grimoire_name=grimoire_name,
+                chapter_name=chapter,
+                plot_name=plot_name,
+                fig=fig,
+                grimoire_secret=args.secret,
+                grimoire_server=server_url,
+            )
+            print(f"  [OK] {chapter}/{plot_name}")
+        except Exception as e:
+            print(f"  [FAIL] {chapter}/{plot_name}: {e}")
+
+    print("-" * 40)
+    print("Done!")
+
+
+def main():
+    default_server = get_grimoire_server()
+    default_host = default_server.split("://")[-1].split(":")[0]
+    default_port = int(default_server.split(":")[-1])
+    default_secret = get_grimoire_secret()
+
+    parser = argparse.ArgumentParser(
+        prog="grimoireplot",
+        description="GrimoirePlot - Live dashboard for Plotly-compatible plots",
+    )
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # Serve command
+    serve_parser = subparsers.add_parser("serve", help="Start the GrimoirePlot server")
+    serve_parser.add_argument(
+        "--host",
+        type=str,
+        default=default_host,
+        help=f"Host to bind the server (default: {default_host})",
+    )
+    serve_parser.add_argument(
+        "--port",
+        type=int,
+        default=default_port,
+        help=f"Port to bind the server (default: {default_port})",
+    )
+    serve_parser.set_defaults(func=serve_command)
+
+    # Push samples command
+    push_parser = subparsers.add_parser(
+        "push-samples", help="Push sample plots to test the server"
+    )
+    push_parser.add_argument(
+        "--host",
+        type=str,
+        default=default_host,
+        help=f"Server host (default: {default_host})",
+    )
+    push_parser.add_argument(
+        "--port",
+        type=int,
+        default=default_port,
+        help=f"Server port (default: {default_port})",
+    )
+    push_parser.add_argument(
+        "--secret",
+        type=str,
+        default=default_secret,
+        help="Grimoire secret for authentication",
+    )
+    push_parser.add_argument(
+        "--grimoire-name",
+        type=str,
+        default="test_grimoire",
+        help="Name of the grimoire to create (default: test_grimoire)",
+    )
+    push_parser.set_defaults(func=push_samples_command)
+
+    # Live test command
+    live_parser = subparsers.add_parser(
+        "live-test", help="Test live plot updates by adding datapoints over time"
+    )
+    live_parser.add_argument(
+        "--host",
+        type=str,
+        default=default_host,
+        help=f"Server host (default: {default_host})",
+    )
+    live_parser.add_argument(
+        "--port",
+        type=int,
+        default=default_port,
+        help=f"Server port (default: {default_port})",
+    )
+    live_parser.add_argument(
+        "--secret",
+        type=str,
+        default=default_secret,
+        help="Grimoire secret for authentication",
+    )
+    live_parser.add_argument(
+        "--grimoire-name",
+        type=str,
+        default="live_test",
+        help="Name of the grimoire to create (default: live_test)",
+    )
+    live_parser.add_argument(
+        "--interval",
+        type=float,
+        default=0.2,
+        help="Interval between datapoints in seconds (default: 0.2)",
+    )
+    live_parser.add_argument(
+        "--max-points",
+        type=int,
+        default=0,
+        help="Maximum number of points to add (0 = unlimited, default: 0)",
+    )
+    live_parser.set_defaults(func=live_test_command)
+
+    args = parser.parse_args()
+
+    if args.command is None:
+        parser.print_help()
+        return
+
+    args.func(args)
+
+
+if __name__ in {"__main__", "__mp_main__"}:
+    main()

grimoireplot/models.py

@@ -0,0 +1,210 @@
+# SPDX-FileCopyrightText: Copyright © 2026 Idiap Research Institute <contact@idiap.ch>
+# SPDX-FileContributor: William Droz <william.droz@idiap.ch>
+# SPDX-License-Identifier: MIT
+
+import os
+from typing import Optional
+from datetime import datetime
+from sqlmodel import Field, Relationship, SQLModel, create_engine, Session
+from sqlalchemy import ForeignKeyConstraint
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+class AddPlotRequest(SQLModel):
+    grimoire_name: str
+    chapter_name: str
+    plot_name: str
+    json_data: str
+
+
+class Grimoire(SQLModel, table=True):
+    name: str = Field(primary_key=True)
+
+    chapters: list["Chapter"] = Relationship(
+        back_populates="grimoire", cascade_delete=True
+    )
+
+
+class Chapter(SQLModel, table=True):
+    name: str = Field(primary_key=True)
+    grimoire_name: str = Field(primary_key=True, foreign_key="grimoire.name")
+
+    grimoire: Grimoire = Relationship(back_populates="chapters")
+
+    plots: list["Plot"] = Relationship(back_populates="chapter", cascade_delete=True)
+
+
+class Plot(SQLModel, table=True):
+    __table_args__ = (
+        ForeignKeyConstraint(
+            ["chapter_name", "grimoire_name"], ["chapter.name", "chapter.grimoire_name"]
+        ),
+    )
+
+    name: str = Field(primary_key=True)
+    chapter_name: str = Field(primary_key=True)
+    grimoire_name: str = Field(primary_key=True)
+    json_data: str
+    created_at: datetime = Field(default_factory=datetime.now)
+
+    chapter: Chapter = Relationship(back_populates="plots")
+
+
+def get_engine():
+    if os.getenv("GRIMOIRE_TEST", "").lower() in ("1", "true", "yes"):
+        sqlite_file_name = "database-deleteme.db"
+        grimoire_db = f"sqlite:///{sqlite_file_name}"
+    elif (grimoire_db := os.getenv("GRIMOIRE_DB")) is None:
+        sqlite_file_name = "database.db"
+        grimoire_db = f"sqlite:///{sqlite_file_name}"
+    return create_engine(grimoire_db)
+
+
+def create_db_and_tables():
+    engine = get_engine()
+    SQLModel.metadata.create_all(engine)
+
+
+def get_all_grimoires() -> list[Grimoire]:
+    """Get all grimoires with their chapters and plots."""
+    engine = get_engine()
+    with Session(engine) as session:
+        from sqlmodel import select
+
+        statement = select(Grimoire)
+        grimoires = session.exec(statement).all()
+        # Ensure relationships are loaded
+        result = []
+        for grimoire in grimoires:
+            # Access chapters to load them
+            _ = grimoire.chapters
+            for chapter in grimoire.chapters:
+                # Access plots to load them
+                _ = chapter.plots
+            result.append(grimoire)
+        return result
+
+
+def get_grimoire_with_data(grimoire_name: str) -> Optional[Grimoire]:
+    """Get a specific grimoire with all its chapters and plots."""
+    engine = get_engine()
+    with Session(engine) as session:
+        grimoire = session.get(Grimoire, grimoire_name)
+        if grimoire:
+            # Load relationships
+            _ = grimoire.chapters
+            for chapter in grimoire.chapters:
+                _ = chapter.plots
+        return grimoire
+
+
+def add_plot(
+    grimoire_name: str, chapter_name: str, plot_name: str, json_data: str
+) -> Plot:
+    """Add a plot to a grimoire/chapter, creating them if they don't exist.
+
+    If the grimoire exists, use it, else create it.
+    If the chapter exists, use it, else create it.
+    If the plot exists, replace it, else add it.
+
+    TODO: check if json_data is valid plotly, if not raise exception.
+    """
+
+    engine = get_engine()
+
+    with Session(engine) as session:
+        # Get or create Grimoire
+        grimoire = session.get(Grimoire, grimoire_name)
+        if grimoire is None:
+            grimoire = Grimoire(name=grimoire_name)
+            session.add(grimoire)
+            session.commit()
+            session.refresh(grimoire)
+
+        # Get or create Chapter
+        chapter = session.get(Chapter, (chapter_name, grimoire_name))
+        if chapter is None:
+            chapter = Chapter(name=chapter_name, grimoire_name=grimoire_name)
+            session.add(chapter)
+            session.commit()
+            session.refresh(chapter)
+
+        # Get or create/replace Plot
+        plot = session.get(Plot, (plot_name, chapter_name, grimoire_name))
+        if plot is None:
+            plot = Plot(
+                name=plot_name,
+                chapter_name=chapter_name,
+                grimoire_name=grimoire_name,
+                json_data=json_data,
+            )
+            session.add(plot)
+        else:
+            plot.json_data = json_data
+            session.add(plot)
+
+        session.commit()
+        session.refresh(plot)
+
+        return plot
+
+
+def delete_plot(grimoire_name: str, chapter_name: str, plot_name: str) -> bool:
+    """Delete a plot by composite key. Returns True if deleted, False if not found."""
+    engine = get_engine()
+    with Session(engine) as session:
+        plot = session.get(Plot, (plot_name, chapter_name, grimoire_name))
+        if plot is None:
+            return False
+        session.delete(plot)
+        session.commit()
+        return True
+
+
+def delete_chapter(grimoire_name: str, chapter_name: str) -> bool:
+    """Delete a chapter and all its plots. Returns True if deleted, False if not found."""
+    engine = get_engine()
+    with Session(engine) as session:
+        chapter = session.get(Chapter, (chapter_name, grimoire_name))
+        if chapter is None:
+            return False
+        session.delete(chapter)
+        session.commit()
+        return True
+
+
+def delete_grimoire(grimoire_name: str) -> bool:
+    """Delete a grimoire and all its chapters and plots. Returns True if deleted, False if not found."""
+    engine = get_engine()
+    with Session(engine) as session:
+        grimoire = session.get(Grimoire, grimoire_name)
+        if grimoire is None:
+            return False
+        session.delete(grimoire)
+        session.commit()
+        return True
+
+
+def get_chapter_with_plots(grimoire_name: str, chapter_name: str) -> Optional[Chapter]:
+    """Get a specific chapter with all its plots."""
+    engine = get_engine()
+    with Session(engine) as session:
+        chapter = session.get(Chapter, (chapter_name, grimoire_name))
+        if chapter:
+            # Load relationships
+            _ = chapter.plots
+        return chapter
+
+
+def get_plots_for_chapter(grimoire_name: str, chapter_name: str) -> list[Plot]:
+    """Get all plots for a specific chapter."""
+    engine = get_engine()
+    with Session(engine) as session:
+        from sqlmodel import select
+
+        statement = select(Plot).where(
+            Plot.chapter_name == chapter_name, Plot.grimoire_name == grimoire_name
+        )
+        return list(session.exec(statement).all())

grimoireplot/server.py

@@ -0,0 +1,90 @@
+# SPDX-FileCopyrightText: Copyright © 2026 Idiap Research Institute <contact@idiap.ch>
+# SPDX-FileContributor: William Droz <william.droz@idiap.ch>
+# SPDX-License-Identifier: MIT
+
+from fastapi import HTTPException, Request
+from nicegui import app, ui
+from grimoireplot.common import get_grimoire_secret
+from grimoireplot.models import (
+    AddPlotRequest,
+    create_db_and_tables,
+    add_plot,
+    delete_plot,
+    delete_chapter,
+    delete_grimoire,
+)
+
+from grimoireplot.ui import dashboard_ui, refresh_chapter_plots
+from grimoireplot.ui_elements import setup_theme
+
+_GRIMOIRE_SECRET = get_grimoire_secret()
+
+
+def verify_secret(request: Request):
+    if (secret := request.headers.get("grimoire-secret")) is None:
+        raise HTTPException(status_code=401, detail="grimoire-secret not found")
+    if secret != _GRIMOIRE_SECRET:
+        raise HTTPException(status_code=403, detail="invalid grimoire-secret")
+
+
+def my_app(host: str = "localhost", port: int = 8080):
+    create_db_and_tables()
+
+    @app.post("/add_plot")
+    def add_plot_endpoint(add_plot_request: AddPlotRequest, request: Request):
+        verify_secret(request)
+        plot = add_plot(
+            grimoire_name=add_plot_request.grimoire_name,
+            chapter_name=add_plot_request.chapter_name,
+            plot_name=add_plot_request.plot_name,
+            json_data=add_plot_request.json_data,
+        )
+        # Try to refresh only the specific chapter's plots
+        # If the chapter doesn't exist in UI yet (new grimoire/chapter), refresh the whole dashboard
+        if not refresh_chapter_plots(
+            add_plot_request.grimoire_name, add_plot_request.chapter_name
+        ):
+            dashboard_ui.refresh()
+        return {"status": "success", "plot_name": plot.name}
+
+    @app.delete("/grimoire/{grimoire_name}/chapter/{chapter_name}/plot/{plot_name}")
+    def delete_plot_endpoint(
+        grimoire_name: str, chapter_name: str, plot_name: str, request: Request
+    ):
+        verify_secret(request)
+        if not delete_plot(grimoire_name, chapter_name, plot_name):
+            raise HTTPException(status_code=404, detail="Plot not found")
+        dashboard_ui.refresh()
+        return {"status": "success", "deleted": plot_name}
+
+    @app.delete("/grimoire/{grimoire_name}/chapter/{chapter_name}")
+    def delete_chapter_endpoint(
+        grimoire_name: str, chapter_name: str, request: Request
+    ):
+        verify_secret(request)
+        if not delete_chapter(grimoire_name, chapter_name):
+            raise HTTPException(status_code=404, detail="Chapter not found")
+        dashboard_ui.refresh()
+        return {"status": "success", "deleted": chapter_name}
+
+    @app.delete("/grimoire/{grimoire_name}")
+    def delete_grimoire_endpoint(grimoire_name: str, request: Request):
+        verify_secret(request)
+        if not delete_grimoire(grimoire_name):
+            raise HTTPException(status_code=404, detail="Grimoire not found")
+        dashboard_ui.refresh()
+        return {"status": "success", "deleted": grimoire_name}
+
+    @ui.page("/")
+    def page():
+        setup_theme()
+        dashboard_ui()
+
+    ui.run(
+        host=host,
+        port=port,
+        dark=True,
+        title="GrimoirePlot - Data Visualization Dashboard",
+        favicon="🔮",
+        reload=False,
+    )