(feat) db csv et admin panels

.gitignore

@@ -0,0 +1,176 @@
+ratings_archive.json
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc

README copy.md

@@ -0,0 +1 @@
+# prompt-arena

app.py

@@ -1,254 +1,300 @@
 import gradio as gr
 import pandas as pd
-import os
-import time
-from threading import Thread
-from arena import PromptArena
+from arena import Arena
+import plotly.graph_objs as go
+import numpy as np
 
 LABEL_A = "Proposition A"
 LABEL_B = "Proposition B"
 
-
-class PromptArenaApp:
-    """
-    Classe pour encapsuler l'arène et gérer l'interface Gradio.
-    """
-
-    def __init__(self, arena: PromptArena) -> None:
-        """
-        Initialise l'application et charge les prompts depuis le fichier CSV.
-        """
-        self.arena: PromptArena = arena
-
-    def select_and_display_match(self):
-        """
-        Sélectionne un match et l'affiche.
-
-        Returns:
-            Tuple contenant:
-            - Le texte du premier prompt
-            - Le texte du second prompt
-            - Un dictionnaire d'état contenant les IDs des prompts
-        """
-
-        try:
-            prompt_a_id, prompt_b_id = self.arena.select_match()
-            prompt_a_text = self.arena.prompts.get(prompt_a_id, "")
-            prompt_b_text = self.arena.prompts.get(prompt_b_id, "")
-
-            state = {"prompt_a_id": prompt_a_id, "prompt_b_id": prompt_b_id}
-
-            return (
-                prompt_a_text,
-                prompt_b_text,
-                state,
-                gr.update(interactive=True),  # button A
-                gr.update(interactive=True),  # button B
-                gr.update(interactive=False),  # match button
-            )
-        except Exception as e:
-            return f"Erreur lors de la sélection d'un match: {str(e)}", "", "", {}
-
-    def record_winner_a(self, state: dict[str, str]):
-        try:
-            prompt_a_id = state["prompt_a_id"]
-            prompt_b_id = state["prompt_b_id"]
-
-            self.arena.record_result(
-                prompt_a_id, prompt_b_id
-            )  # Mettre à jour la progression et le classement
-            progress_info = self.get_progress_info()
-            rankings_table = self.get_rankings_table()
-
-            return (
-                f"Vous avez choisi : {LABEL_A}",
-                progress_info,
-                rankings_table,
-                gr.update(interactive=False),  # button A
-                gr.update(interactive=False),  # button B
-                gr.update(interactive=True),  # match button
+ARENA = Arena()
+ARENA.init_estimates()
+
+
+def select_and_display_match():
+    try:
+        prompt_a, prompt_b = ARENA.select_match()
+        state = {"prompt_a_id": prompt_a["id"], "prompt_b_id": prompt_b["id"]}
+        vote_a_btn_update = gr.update(interactive=True)
+        vote_b_btn_update = gr.update(interactive=True)
+        new_match_btn_update = gr.update(interactive=False)
+        return (
+            prompt_a["text"],
+            prompt_b["text"],
+            state,
+            vote_a_btn_update,
+            vote_b_btn_update,
+            new_match_btn_update,
+        )
+    except Exception as e:
+        return f"Erreur lors de la sélection d'un match: {str(e)}", "", "", {}
+
+
+def record_winner_a(state):
+    try:
+        prompt_a_id = state["prompt_a_id"]
+        prompt_b_id = state["prompt_b_id"]
+        ARENA.record_result(prompt_a_id, prompt_b_id)
+        progress_info = ARENA.get_progress()
+        rankings_table = ARENA.get_rankings()
+        vote_a_btn_update = gr.update(interactive=False)
+        vote_b_btn_update = gr.update(interactive=False)
+        new_match_btn_update = gr.update(interactive=True)
+        return (
+            f"Vous avez choisi : {LABEL_A}",
+            progress_info,
+            rankings_table,
+            vote_a_btn_update,
+            vote_b_btn_update,
+            new_match_btn_update,
+        )
+    except Exception as e:
+        return (
+            f"Erreur lors de l'enregistrement du résultat: {str(e)}",
+            "",
+            pd.DataFrame(),
+        )
+
+
+def record_winner_b(state):
+    try:
+        prompt_a_id = state["prompt_a_id"]
+        prompt_b_id = state["prompt_b_id"]
+        ARENA.record_result(prompt_b_id, prompt_a_id)
+        progress_info = ARENA.get_progress()
+        rankings_table = ARENA.get_rankings()
+        vote_a_btn_update = gr.update(interactive=False)
+        vote_b_btn_update = gr.update(interactive=False)
+        new_match_btn_update = gr.update(interactive=True)
+        return (
+            f"Vous avez choisi : {LABEL_B}",
+            progress_info,
+            rankings_table,
+            vote_a_btn_update,
+            vote_b_btn_update,
+            new_match_btn_update,
+        )
+    except Exception as e:
+        return (
+            f"Erreur lors de l'enregistrement du résultat: {str(e)}",
+            "",
+            pd.DataFrame(),
+        )
+
+
+def update_table(table_name, df):
+    """Met à jour le fichier CSV de la table spécifiée à partir du DataFrame édité."""
+    ARENA.replace(table_name, df)
+    return None
+
+
+def admin_visible(request: gr.Request):
+    is_admin = request.username == "admin"
+    return gr.update(visible=is_admin)
+
+
+def welcome_user(request: gr.Request):
+    return request.username
+
+
+def plot_estimates_distribution():
+    """Affiche une gaussienne par prompt (Plotly) + lignes verticales pointillées sur les moyennes."""
+    estimates = ARENA.load("estimates")
+    prompts = ARENA.load("prompts")
+    if estimates.empty or prompts.empty:
+        fig = go.Figure()
+        fig.add_annotation(
+            text="Aucune estimation disponible", x=0.5, y=0.5, showarrow=False
+        )
+        return fig
+    x = np.linspace(
+        estimates["mu"].min() - 3 * estimates["sigma"].max(),
+        estimates["mu"].max() + 3 * estimates["sigma"].max(),
+        500,
+    )
+    fig = go.Figure()
+    shapes = []
+    # Une gaussienne par prompt
+    for _, row in estimates.iterrows():
+        mu = row["mu"]
+        sigma = row["sigma"]
+        prompt_id = row["prompt_id"] if "prompt_id" in row else row["id"]
+        # Chercher le nom du prompt
+        name = str(prompt_id)
+        if "name" in prompts.columns:
+            match = prompts[prompts["id"] == prompt_id]
+            if not match.empty:
+                name = match.iloc[0]["name"]
+        y = 1 / (sigma * np.sqrt(2 * np.pi)) * np.exp(-0.5 * ((x - mu) / sigma) ** 2)
+        fig.add_trace(
+            go.Scatter(
+                x=x,
+                y=y,
+                mode="lines",
+                name=f"{name}",
+                hovertemplate=f"<b>{name}</b><br>Score (mu): {mu:.2f}<br>Sigma: {sigma:.2f}<extra></extra>",
             )
-        except Exception as e:
-            return (
-                f"Erreur lors de l'enregistrement du résultat: {str(e)}",
-                "",
-                pd.DataFrame(),
-            )
-
-    def record_winner_b(self, state: dict[str, str]):
-        try:
-            prompt_a_id = state["prompt_a_id"]
-            prompt_b_id = state["prompt_b_id"]
-
-            self.arena.record_result(
-                prompt_b_id, prompt_a_id
-            )  # Mettre à jour la progression et le classement
-            progress_info = self.get_progress_info()
-            rankings_table = self.get_rankings_table()
-
-            return (
-                f"Vous avez choisi : {LABEL_B}",
-                progress_info,
-                rankings_table,
-                gr.update(interactive=False),  # button A
-                gr.update(interactive=False),  # button B
-                gr.update(interactive=True),  # match button
+        )
+        # Ajout de la ligne verticale pointillée à mu (en gris)
+        shapes.append(
+            dict(
+                type="line",
+                x0=mu,
+                x1=mu,
+                y0=0,
+                y1=max(y),
+                line=dict(
+                    color="gray",
+                    width=2,
+                    dash="dot",
+                ),
+                xref="x",
+                yref="y",
             )
-        except Exception as e:
-            return (
-                f"Erreur lors de l'enregistrement du résultat: {str(e)}",
-                "",
-                pd.DataFrame(),
-            )
-
-    def get_progress_info(self) -> str:
-        """
-        Obtient les informations sur la progression du tournoi.
-
-        Returns:
-            str: Message formaté contenant les statistiques de progression
-        """
-        if not self.arena:
-            return "Aucune arène initialisée. Veuillez d'abord charger des prompts."
-
-        try:
-            progress = self.arena.get_progress()
-
-            info = f"Prompts: {progress['total_prompts']}\n"
-            info += f"Matchs joués: {progress['total_matches']}\n"
-            info += f"Progression: {progress['progress']:.2f}%\n"
-            info += (
-                f"Matchs restants estimés: {progress['estimated_remaining_matches']}\n"
-            )
-            info += f"Incertitude moyenne (σ): {progress['avg_sigma']:.4f}"
-
-            return info
-        except Exception as e:
-            return f"Erreur lors de la récupération de la progression: {str(e)}"
-
-    def get_rankings_table(self) -> pd.DataFrame:
-        """
-        Obtient le classement des prompts sous forme de tableau.
-
-        Returns:
-            pd.DataFrame: Tableau de classement des prompts
-        """
-        if not self.arena:
-            return pd.DataFrame([{"Erreur": "Aucune arène initialisée"}])
-
-        try:
-            rankings = self.arena.get_rankings()
-
-            df = pd.DataFrame(rankings)
-            df = df[["rank", "prompt_id", "score"]]
-            df = df.rename(
-                columns={
-                    "rank": "Rang",
-                    "prompt_id": "ID",
-                    "score": "Score",
-                }
-            )
-
-            return df
-        except Exception as e:
-            return pd.DataFrame([{"Erreur": str(e)}])
-
-    def create_ui(self) -> gr.Blocks:
-        """
-        Crée l'interface utilisateur Gradio.
-
-        Returns:
-            gr.Blocks: L'application Gradio configurée
-        """
-
-        with gr.Blocks(title="Prompt Arena", theme=gr.themes.Ocean()) as app:
-            gr.Markdown('<h1 style="text-align:center;">🥊 Prompt Arena 🥊</h1>')
-
+        )
+    fig.update_layout(
+        title="Distribution gaussienne de chaque prompt",
+        xaxis_title="Score (mu)",
+        yaxis_title="Densité",
+        template="plotly_white",
+        shapes=shapes,
+    )
+    return fig
+
+
+with gr.Blocks(
+    title="Prompt Arena",
+    #    theme=gr.themes.Default.load("theme_schema_miku.json"),
+) as demo:
+    state = gr.State()
+
+    with gr.Row():
+        username = gr.Markdown("")
+        gr.Button("Logout", link="/logout", scale=0, min_width=50)
+
+    gr.Markdown(
+        '<h1 style="text-align:center;"> Concours du meilleur Prompt Engineer  </h1>'
+    )
+
+    progress_info = gr.Textbox(
+        label="Progression du concours",
+        value=ARENA.get_progress(),
+        interactive=False,
+        lines=2,
+    )
+
+    with gr.Tabs() as tabs:
+        # Onglet des Combats
+        with gr.TabItem("Combats"):
             with gr.Row():
-                select_btn = gr.Button("Lancer un nouveau match", variant="primary")
+                new_match_btn = gr.Button("Lancer un nouveau match", variant="primary")
 
             with gr.Row():
-                proposition_a = gr.Textbox(label=LABEL_A, interactive=False)
-                proposition_b = gr.Textbox(label=LABEL_B, interactive=False)
-
-            with gr.Row():
-                vote_a_btn = gr.Button("Choisir " + LABEL_A, interactive=False)
-                vote_b_btn = gr.Button("Choisir " + LABEL_B, interactive=False)
-
+                with gr.Column():
+                    proposition_a = gr.Textbox(label=LABEL_A, interactive=False)
+                    vote_a_btn = gr.Button("Choisir " + LABEL_A, interactive=False)
+                with gr.Column():
+                    proposition_b = gr.Textbox(label=LABEL_B, interactive=False)
+                    vote_b_btn = gr.Button("Choisir " + LABEL_B, interactive=False)
             result = gr.Textbox("Résultat", interactive=False)
-            progress_info = gr.Textbox(
-                label="Progression du concours", interactive=False
-            )
-            rankings_table = gr.DataFrame(label="Classement des prompts")
-            state = gr.State()  # contient les IDs des prompts du match en cours
-
-            select_btn.click(
-                self.select_and_display_match,
-                inputs=[],
-                outputs=[
-                    proposition_a,
-                    proposition_b,
-                    state,
-                    vote_a_btn,
-                    vote_b_btn,
-                    select_btn,
-                ],
+
+            #        with gr.TabItem("Classement"):
+            rankings_table = gr.DataFrame(
+                label="Classement des prompts",
+                value=ARENA.get_rankings(),
+                interactive=True,
             )
-            vote_a_btn.click(
-                self.record_winner_a,
-                inputs=[state],
-                outputs=[
-                    result,
-                    progress_info,
-                    rankings_table,
-                    vote_a_btn,
-                    vote_b_btn,
-                    select_btn,
-                ],
+
+        # Onglet des Résultats
+        with gr.TabItem("Admin") as admin_tab:
+            with gr.Accordion("Prompts", open=False):
+                prompts_table = gr.DataFrame(
+                    value=ARENA.load("prompts"),
+                    interactive=True,
+                )
+            with gr.Accordion("Estimates", open=False):
+                estimates_table = gr.DataFrame(
+                    label="Estimations",
+                    value=ARENA.load("estimates"),
+                    interactive=True,
+                )
+            with gr.Accordion("Votes", open=False):
+                votes_table = gr.DataFrame(
+                    label="Votes",
+                    value=ARENA.load("votes"),
+                    interactive=True,
+                )
+            gr.Plot(plot_estimates_distribution, label="Distribution des estimations")
+            prompts_table.change(
+                update_table,
+                inputs=[gr.Markdown("prompts", visible=False), prompts_table],
+                outputs=None,
             )
-            vote_b_btn.click(
-                self.record_winner_b,
-                inputs=[state],
-                outputs=[
-                    result,
-                    progress_info,
-                    rankings_table,
-                    vote_a_btn,
-                    vote_b_btn,
-                    select_btn,
-                ],
+            estimates_table.change(
+                update_table,
+                inputs=[gr.Markdown("estimates", visible=False), estimates_table],
+                outputs=None,
             )
-
-            with gr.Row():
-                prompt_id_box = gr.Textbox(label="ID du prompt", interactive=True)
-                prompt_text_box = gr.Textbox(label="Texte du prompt", interactive=True)
-                save_btn = gr.Button("Ajouter le prompt", variant="secondary")
-
-            def save_prompt(prompt_id, prompt_text):
-                self.arena.add_prompt(prompt_id, prompt_text)
-                prompts = pd.read_csv("prompts.csv", header=None)
-                prompts.columns = [
-                    "Texte",
-                ]  # ou adaptez selon la structure réelle
-                return prompts
-
-            prompts_lists = gr.Dataframe(label="Liste des prompts")
-            save_btn.click(
-                save_prompt,
-                inputs=[prompt_id_box, prompt_text_box],
-                outputs=prompts_lists,
+            votes_table.change(
+                update_table,
+                inputs=[gr.Markdown("votes", visible=False), votes_table],
+                outputs=None,
             )
 
-            gr.Row([progress_info, rankings_table])
-
-        return app
+    new_match_btn.click(
+        select_and_display_match,
+        inputs=[],
+        outputs=[
+            proposition_a,
+            proposition_b,
+            state,
+            vote_a_btn,
+            vote_b_btn,
+            new_match_btn,
+        ],
+    )
+
+    # Callbacks pour les deux onglets
+    vote_a_btn.click(
+        record_winner_a,
+        inputs=[state],
+        outputs=[
+            result,
+            progress_info,
+            rankings_table,
+            vote_a_btn,
+            vote_b_btn,
+            new_match_btn,
+        ],
+    )
+    vote_b_btn.click(
+        record_winner_b,
+        inputs=[state],
+        outputs=[
+            result,
+            progress_info,
+            rankings_table,
+            vote_a_btn,
+            vote_b_btn,
+            new_match_btn,
+        ],
+    )
+
+    demo.load(admin_visible, None, admin_tab)
+    demo.load(welcome_user, None, username)
+
+
+def arena_auth(username, password):
+    if username == "admin":
+        return (
+            password == "fred"
+        )  # todo : mettre le mot de passe en variable d'environnement
+    else:
+        return username == password
 
 
 # Exemple d'utilisation
 if __name__ == "__main__":
-    # load the prompts from the CSV file
-    prompts = pd.read_csv("prompts.csv", header=None).iloc[:, 0].tolist()
-    arena = PromptArena(prompts=prompts)
-    app_instance = PromptArenaApp(arena=arena)
-    app = app_instance.create_ui()
-    app.launch()
+    demo.launch(
+        auth_message="Connexion à l'arène des prompts", auth=arena_auth
+    )  # ajouter share=True pour partager l'interface

arena.py

@@ -1,151 +1,129 @@
-import trueskill
+import trueskill as ts
+import pandas as pd
 import random
-import json
-import os
 import datetime
 from typing import Dict, List, Tuple, Union
+import db
 import pandas as pd
+from typing import TypedDict
+
+MU_init = ts.Rating().mu
+SIGMA_init = ts.Rating().sigma
+
+
+class Prompt(TypedDict):
+    id: int
+    name: str
+    text: str
 
 
-class PromptArena:
+class Arena:
     """
     Une arène pour comparer et classer des prompts en utilisant l'algorithme TrueSkill.
-
-    Cette classe permet d'organiser des "matchs" entre prompts où des utilisateurs
-    choisissent leur préféré, mettant à jour les classements TrueSkill en fonction
-    des résultats.
     """
 
-    def __init__(
-        self, prompts: List[str], results_file: str = "ratings_archive.json"
-    ) -> None:
+    def init_estimates(self, reboot=True) -> None:
         """
-        Initialise une arène de prompts.
-
-        Args:
-            prompts: Liste de textes de prompts
-            results_file: Chemin du fichier pour sauvegarder/charger les ratings
+        Initialise les estimations des prompts avec des ratings TrueSkill par défaut.
+        reboot : si le fichier estimates.csv existe déjà, on le laisse tel quel.
         """
-        self.prompts: Dict[str, str] = {
-            str(idx + 1): prompt for idx, prompt in enumerate(prompts)
-        }
-        self.ratings: Dict[str, trueskill.Rating] = {}  # {prompt_id: trueskill.Rating}
-        self.results_file: str = results_file
-        self.match_history: List[Dict[str, str]] = []
-
-        # Charger les ratings si le fichier existe
-        self._load_ratings()
-
-        # Initialiser les ratings pour les nouveaux prompts
-        for prompt_id in self.prompts:
-            if prompt_id not in self.ratings:
-                self.ratings[prompt_id] = trueskill.Rating()
-
-    def _load_ratings(self) -> None:
-        """Charge les ratings depuis un fichier JSON si disponible"""
-        if os.path.exists(self.results_file):
-            with open(self.results_file, "r", encoding="utf-8") as f:
-                data = json.load(f)
-
-                # Convertir les données stockées en objets trueskill.Rating
-                for prompt_id, rating_data in data["ratings"].items():
-                    self.ratings[prompt_id] = trueskill.Rating(
-                        mu=rating_data["mu"], sigma=rating_data["sigma"]
-                    )
-
-                self.match_history = data.get("match_history", [])
-
-    def _save_ratings(self) -> None:
-        """Sauvegarde les ratings et l'historique dans un fichier JSON"""
-        data = {
-            "ratings": {
-                prompt_id: {"mu": rating.mu, "sigma": rating.sigma}
-                for prompt_id, rating in self.ratings.items()
-            },
-            "match_history": self.match_history,
-        }
-
-        with open(self.results_file, "w", encoding="utf-8") as f:
-            json.dump(data, f, ensure_ascii=False, indent=2)
-
-    def add_prompt(self, prompt_id: str, prompt_text: str) -> None:
+        estimates = db.load("estimates")
+        if not estimates.empty and reboot:
+            return None
+        if estimates.empty:
+            for i in db.load("prompts")["id"].to_list():
+                db.insert(
+                    "estimates",
+                    {
+                        "prompt_id": i,
+                        "mu": MU_init,
+                        "sigma": SIGMA_init,
+                    },
+                )
+
+    def load(self, table_name: str) -> pd.DataFrame:
+        """
+        fonction back pour l'UI.
+        Charge les données d'une table depuis le fichier CSV.
         """
-        Ajoute un nouveau prompt à l'arène.
+        return db.load(table_name)
 
-        Args:
-            prompt_id: Identifiant unique du prompt
-            prompt_text: Texte du prompt
+    def replace(self, table_name: str, df: pd.DataFrame) -> pd.DataFrame:
         """
-        self.prompts[prompt_id] = prompt_text
-        prompts = pd.read_csv("prompts.csv", header=None)
-        prompts.loc[len(prompts)] = [prompt_text]
-        prompts.to_csv("prompts.csv", index=False, header=False)
-        if prompt_id not in self.ratings:
-            self.ratings[prompt_id] = trueskill.Rating()
-        self._save_ratings()
-
-    def select_match(self) -> Tuple[str, str]:
+        fonction back pour l'UI.
+        Remplace le contenu d'une table par les données du fichier CSV.
+        Pour l'admin uniquement
         """
-        Sélectionne deux prompts pour un match en privilégiant ceux avec une grande incertitude.
-
-        La stratégie est de sélectionner d'abord le prompt avec la plus grande incertitude (sigma),
-        puis de trouver un adversaire avec un niveau (mu) similaire.
+        return db.replace(table_name, df)
 
+    def select_match(self) -> Tuple[Prompt, Prompt]:
+        """
+        Sélectionne deux prompts pour un match en privilégiant ceux avec une grande incertitude.
         Returns:
             Un tuple contenant les IDs des deux prompts à comparer (prompt_a, prompt_b)
         """
-        # Stratégie: choisir des prompts avec sigma élevé et des niveaux similaires
-        prompt_ids = list(self.prompts.keys())
-
-        # Trier par incertitude (sigma) décroissante
-        prompt_ids.sort(key=lambda pid: self.ratings[pid].sigma, reverse=True)
-
-        # Sélectionner le premier prompt (plus grande incertitude)
-        prompt_a = prompt_ids[0]
-
-        # Pour le second, trouver un prompt proche en niveau (mu)
-        mu_a = self.ratings[prompt_a].mu
+        # le prompt le plus incertain (sigma le plus élevé)
+        estimates = db.load("estimates")
+        estimate_a = estimates.sort_values(by="sigma", ascending=False).iloc[0]
+
+        # le prompt le plus proche en niveau (mu) du prompt_a
+        estimate_b = (
+            estimates.loc[estimates["prompt_id"] != estimate_a["prompt_id"]]
+            .assign(delta_mu=lambda df_: abs(df_["mu"] - estimate_a["mu"]))
+            .sort_values(by="delta_mu", ascending=True)
+            .iloc[0]
+        )
 
-        # Trier les prompts restants par proximité de mu
-        remaining_prompts = [p for p in prompt_ids if p != prompt_a]
-        remaining_prompts.sort(key=lambda pid: abs(self.ratings[pid].mu - mu_a))
+        prompts = db.load("prompts")
+        prompt_a = prompts.query(f"id == {estimate_a['prompt_id']}").iloc[0].to_dict()
+        prompt_b = prompts.query(f"id == {estimate_b['prompt_id']}").iloc[0].to_dict()
+        # We need to update the selection strategy to prefer prompts with high uncertainty
+        # but also consider prompts that are close in ranking (within 5 positions)
 
-        # Prendre un prompt parmi les 3 plus proches (avec un peu de randomisation)
-        top_n = min(3, len(remaining_prompts))
-        prompt_b = random.choice(remaining_prompts[:top_n])
+        # Create pairs of prompts that are at most 5 positions apart in the ranking
+        # close_pairs = []
+        # for i in range(len(prompt_ids)):
+        #     for j in range(i + 1, min(i + 6, len(prompt_ids))):
+        #         close_pairs.append((prompt_ids[i], prompt_ids[j]))
 
         return prompt_a, prompt_b
 
     def record_result(self, winner_id: str, loser_id: str) -> None:
-        """
-        Enregistre le résultat d'un match et met à jour les ratings.
-
-        Args:
-            winner_id: ID du prompt gagnant
-            loser_id: ID du prompt perdant
-        """
         # Obtenir les ratings actuels
-        winner_rating = self.ratings[winner_id]
-        loser_rating = self.ratings[loser_id]
+        estimates = db.load("estimates")
+        winner_estimate = (
+            estimates[estimates["prompt_id"] == winner_id].iloc[0].to_dict()
+        )
+        loser_estimate = estimates[estimates["prompt_id"] == loser_id].iloc[0].to_dict()
 
-        # Mettre à jour les ratings (TrueSkill s'occupe des calculs)
-        self.ratings[winner_id], self.ratings[loser_id] = trueskill.rate_1vs1(
-            winner_rating, loser_rating
+        winner_rating = ts.Rating(winner_estimate["mu"], winner_estimate["sigma"])
+        loser_rating = ts.Rating(loser_estimate["mu"], loser_estimate["sigma"])
+
+        winner_new_rating, loser_new_rating = ts.rate_1vs1(winner_rating, loser_rating)
+
+        db.update(
+            "estimates",
+            winner_estimate["id"],
+            {"mu": winner_new_rating.mu, "sigma": winner_new_rating.sigma},
+        )
+        db.update(
+            "estimates",
+            loser_estimate["id"],
+            {"mu": loser_new_rating.mu, "sigma": loser_new_rating.sigma},
         )
 
-        # Enregistrer le match dans l'historique
-        self.match_history.append(
+        db.insert(
+            "votes",
             {
-                "winner": winner_id,
-                "loser": loser_id,
-                "timestamp": str(datetime.datetime.now()),
-            }
+                "winner_id": winner_id,
+                "loser_id": loser_id,
+                #                "timestamp": datetime.datetime.now().isoformat(),
+            },
         )
 
-        # Sauvegarder les résultats
-        self._save_ratings()
+        return None
 
-    def get_rankings(self) -> List[Dict[str, Union[int, str, float]]]:
+    def get_rankings(self) -> pd.DataFrame:
         """
         Obtient le classement actuel des prompts.
 
@@ -153,29 +131,16 @@ class PromptArena:
             Liste de dictionnaires contenant le classement de chaque prompt avec
             ses informations (rang, id, texte, mu, sigma, score)
         """
-        # Trier les prompts par "conserved expected score" = mu - 3*sigma
-        # (une façon conservatrice d'estimer la compétence en tenant compte de l'incertitude)
-        sorted_prompts = sorted(
-            self.ratings.items(), key=lambda x: x[1].mu - 3 * x[1].sigma, reverse=True
+
+        prompts = db.load("prompts")
+        estimates = db.load("estimates").drop(columns=["id"])
+        rankings = prompts.merge(estimates, left_on="id", right_on="prompt_id").drop(
+            columns=["id", "prompt_id"]
         )
+        return rankings.sort_values(by="mu", ascending=False)
+        # eventuellement afficher plutôt mu - 3 sigma pour être conservateur
 
-        rankings = []
-        for i, (prompt_id, rating) in enumerate(sorted_prompts, 1):
-            prompt_text = self.prompts.get(prompt_id, "Prompt inconnu")
-            rankings.append(
-                {
-                    "rank": i,
-                    "prompt_id": prompt_id,
-                    "prompt": prompt_text,
-                    "mu": rating.mu,
-                    "sigma": rating.sigma,
-                    "score": rating.mu - 3 * rating.sigma,  # Score conservateur
-                }
-            )
-
-        return rankings
-
-    def get_progress(self) -> Dict[str, Union[int, float]]:
+    def get_progress(self) -> str:
         """
         Renvoie des statistiques sur la progression du tournoi.
 
@@ -187,22 +152,19 @@ class PromptArena:
             - progress: pourcentage estimé de progression du tournoi
             - estimated_remaining_matches: estimation du nombre de matchs restants
         """
-        total_prompts = len(self.prompts)
-        total_matches = len(self.match_history)
+        prompts = db.load("prompts")
+        estimates = db.load("estimates")
+        votes = db.load("votes")
 
-        avg_sigma = sum(r.sigma for r in self.ratings.values()) / max(
-            1, len(self.ratings)
-        )
+        avg_sigma = estimates["sigma"].mean()
 
         # Estimer quel pourcentage du tournoi est complété
         # En se basant sur la réduction moyenne de sigma par rapport à la valeur initiale
-        initial_sigma = trueskill.Rating().sigma
+        initial_sigma = ts.Rating().sigma
         progress = min(100, max(0, (1 - avg_sigma / initial_sigma) * 100))
 
-        return {
-            "total_prompts": total_prompts,
-            "total_matches": total_matches,
-            "avg_sigma": avg_sigma,
-            "progress": progress,
-            "estimated_remaining_matches": int(total_prompts * 15) - total_matches,
-        }
+        msg = f"""{len(prompts)} propositions à départager
+{len(votes)} matchs joués
+{avg_sigma:.2f} d'incertitude moyenne"""
+
+        return msg

database/estimates.csv

@@ -0,0 +1,6 @@
+id,prompt_id,mu,sigma
+1,1,40.23772508094016,2
+2,2,26.46775376631428,4
+3,3,22.084687989982868,3.547977413152066
+4,4,24.390885439458472,3.2275080660341553
+5,5,9.29883828658184,3.5631194000412036

database/prompts.csv

@@ -0,0 +1,6 @@
+id,name,text
+1,A,Prompt A 100
+2,B,Prompt B 90
+3,C,Prompt C 60
+4,D,Prompt D 55
+5,E,Prompt E 30

database/votes.csv

@@ -0,0 +1,11 @@
+id,winner_id,loser_id
+1,4,5
+2,1,2
+3,2,3
+4,4,5
+5,1,2
+6,4,5
+7,1,2
+8,4,3
+9,3,5
+10,3,5

db.py

@@ -0,0 +1,68 @@
+import pandas as pd
+
+
+"""
+Small Database for managing prompts, estimates, and votes in a simple arena-like application.
+Les données sont stockées dans des fichiers CSV.
+Il faut toujours se référer au fichier et pas à la variable en mémoire.
+La mémoire est propre à chaque utilisateur. 
+Pour être à jour des mises à jours des autres utilisateurs, il faut recharger les données depuis le fichier.
+"""
+
+DATABASE = {
+    "prompts": {
+        "filename": "database/prompts.csv",
+        "columns": ["id", "name", "text"],
+    },
+    "estimates": {
+        "filename": "database/estimates.csv",
+        "columns": ["id", "prompt_id", "mu", "sigma"],
+    },
+    "votes": {
+        "filename": "database/votes.csv",
+        "columns": ["id", "winner_id", "loser_id"],
+    },
+}
+
+
+def load(table_name: str) -> pd.DataFrame:
+    try:
+        result = pd.read_csv(DATABASE[table_name]["filename"])
+    except FileNotFoundError:
+        result = pd.DataFrame(columns=DATABASE[table_name]["columns"])
+    return result
+
+
+def insert(table_name: str, data: dict) -> None:
+    """Inserts data into the specified table.
+    Id is automatically generated .
+    example:
+        db.insert("prompts", {"name": "Test", "text": "This is a test prompt."})
+    """
+    df = load(table_name)
+    data["id"] = 1 if df.empty else df["id"].max() + 1
+    df = pd.concat([df, pd.DataFrame([data])], ignore_index=True)
+    df.to_csv(DATABASE[table_name]["filename"], index=False)
+
+
+def update(table_name: str, row_id: int, data: dict) -> None:
+    """
+    Met à jour les estimations d'un prompt dans la table spécifiée par son id d'estimation.
+    Exemple :
+        db.update("estimates", 3, {"mu": 25.0, "sigma": 8.3})
+    """
+    df = load(table_name)
+    idx = df.index[df["id"] == row_id]
+    if not idx.empty:
+        for key, value in data.items():
+            df.loc[idx, key] = value
+        df.to_csv(DATABASE[table_name]["filename"], index=False)
+
+
+def replace(table_name: str, df: pd.DataFrame) -> None:
+    """
+    Remplace la totalité du contenu de la table spécifiée par le DataFrame fourni.
+    Exemple :
+        db.replace("prompts", df)
+    """
+    df.to_csv(DATABASE[table_name]["filename"], index=False)

pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "prompt-arena"
+version = "0.1.0"
+description = ""
+authors = [
+    {name = "Fred-Oru",email = "[email protected]"}
+]
+readme = "README.md"
+requires-python = ">=3.12,<4.0"
+dependencies = [
+    "trueskill (>=0.4.5,<0.5.0)",
+    "gradio (>=4.0.0)",
+    "pandas (>=2.0.0)",
+    "plotly (>=6.1.2,<7.0.0)",
+]
+
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.group.dev.dependencies]
+ipykernel = "^6.29.5"
+

requirements.txt

@@ -1,3 +1,4 @@
 trueskill>=0.4.5,<0.5.0
 gradio>=4.0.0
-pandas>=2.0.0
+pandas>=2.0.0
+plotly>=6.1.2,<7.0.0

routes.py

@@ -0,0 +1,7 @@
+@app.get("/logout")
+def logout():
+    response = RedirectResponse(url="/", status_code=status.HTTP_302_FOUND)
+    response.delete_cookie(key=f"access-token")
+    response.delete_cookie(key=f"access-token-unsecure")
+    print("Logout user!")
+    return response

theme_schema_miku.json

@@ -0,0 +1 @@
+{"theme": {"_font": [{"__gradio_font__": true, "name": "Quicksand", "class": "google"}, {"__gradio_font__": true, "name": "ui-sans-serif", "class": "font"}, {"__gradio_font__": true, "name": "system-ui", "class": "font"}, {"__gradio_font__": true, "name": "sans-serif", "class": "font"}], "_font_mono": [{"__gradio_font__": true, "name": "IBM Plex Mono", "class": "google"}, {"__gradio_font__": true, "name": "ui-monospace", "class": "font"}, {"__gradio_font__": true, "name": "Consolas", "class": "font"}, {"__gradio_font__": true, "name": "monospace", "class": "font"}], "_stylesheets": ["https://fonts.googleapis.com/css2?family=Quicksand:wght@400;600&display=swap", "https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:wght@400;600&display=swap"], "background_fill_primary": "#FFFFFF", "background_fill_primary_dark": "#000000", "background_fill_secondary": "#dce3e8", "background_fill_secondary_dark": "#242424", "block_background_fill": "#ECF2F7", "block_background_fill_dark": "#191919", "block_border_color": "#dce3e8", "block_border_color_dark": "#242424", "block_border_width": "1px", "block_info_text_color": "#191919", "block_info_text_color_dark": "#ECF2F7", "block_info_text_size": "*text_sm", "block_info_text_weight": "400", "block_label_background_fill": "#ECF2F700", "block_label_background_fill_dark": "#19191900", "block_label_border_color": "#dce3e8", "block_label_border_color_dark": "#242424", "block_label_border_width": "1px", "block_label_margin": "0", "block_label_padding": "*spacing_sm *spacing_lg", "block_label_radius": "calc(*radius_lg - 1px) 0 calc(*radius_lg - 1px) 0", "block_label_right_radius": "0 calc(*radius_lg - 1px) 0 calc(*radius_lg - 1px)", "block_label_shadow": "*block_shadow", "block_label_text_color": "#4EACEF", "block_label_text_color_dark": "#4EACEF", "block_label_text_size": "*text_sm", "block_label_text_weight": "400", "block_padding": "*spacing_xl calc(*spacing_xl + 2px)", "block_radius": "*radius_lg", "block_shadow": "#FFFFFF00", "block_shadow_dark": "#00000000", "block_title_background_fill": "#ECF2F700", "block_title_background_fill_dark": "#19191900", "block_title_border_color": "#dce3e8", "block_title_border_color_dark": "#242424", "block_title_border_width": "0px", "block_title_padding": "0", "block_title_radius": "none", "block_title_text_color": "#4EACEF", "block_title_text_color_dark": "#4EACEF", "block_title_text_size": "*text_md", "block_title_text_weight": "bold", "body_background_fill": "#FFFFFF", "body_background_fill_dark": "#000000", "body_text_color": "#191919", "body_text_color_dark": "#ECF2F7", "body_text_color_subdued": "#636668", "body_text_color_subdued_dark": "#c4c4c4", "body_text_size": "*text_md", "body_text_weight": "400", "border_color_accent": "#dce3e8", "border_color_accent_dark": "#242424", "border_color_accent_subdued": "#dce3e867", "border_color_accent_subdued_dark": "#24242467", "border_color_primary": "#dce3e8", "border_color_primary_dark": "#242424", "button_border_width": "*input_border_width", "button_border_width_dark": "*input_border_width", "button_cancel_background_fill": "#dce3e8", "button_cancel_background_fill_dark": "#242424", "button_cancel_background_fill_hover": "#d0d7db", "button_cancel_background_fill_hover_dark": "#202020", "button_cancel_border_color": "#191919", "button_cancel_border_color_dark": "#ECF2F7", "button_cancel_border_color_hover": "#202020", "button_cancel_border_color_hover_dark": "#a1c3d8", "button_cancel_text_color": "#4EACEF", "button_cancel_text_color_dark": "#4EACEF", "button_cancel_text_color_hover": "#0c6ebd", "button_cancel_text_color_hover_dark": "#0c6ebd", "button_large_padding": "*spacing_lg calc(2 * *spacing_lg)", "button_large_radius": "*radius_lg", "button_large_text_size": "*text_lg", "button_large_text_weight": "600", "button_primary_background_fill": "#4EACEF", "button_primary_background_fill_dark": "#4EACEF", "button_primary_background_fill_hover": "#0c6ebd", "button_primary_background_fill_hover_dark": "#0c6ebd", "button_primary_border_color": "#191919", "button_primary_border_color_dark": "#ECF2F7", "button_primary_border_color_hover": "#202020", "button_primary_border_color_hover_dark": "#a1c3d8", "button_primary_text_color": "#ECF2F7", "button_primary_text_color_dark": "#191919", "button_primary_text_color_hover": "#e1eaf0", "button_primary_text_color_hover_dark": "#141414", "button_secondary_background_fill": "#dce3e8", "button_secondary_background_fill_dark": "#242424", "button_secondary_background_fill_hover": "#d0d7db", "button_secondary_background_fill_hover_dark": "#202020", "button_secondary_border_color": "#dce3e8", "button_secondary_border_color_dark": "#242424", "button_secondary_border_color_hover": "#d0d7db", "button_secondary_border_color_hover_dark": "#202020", "button_secondary_text_color": "#4EACEF", "button_secondary_text_color_dark": "#4EACEF", "button_secondary_text_color_hover": "#0c6ebd", "button_secondary_text_color_hover_dark": "#0c6ebd", "button_shadow": "none", "button_shadow_active": "none", "button_shadow_hover": "none", "button_small_padding": "*spacing_sm calc(2 * *spacing_sm)", "button_small_radius": "*radius_lg", "button_small_text_size": "*text_md", "button_small_text_weight": "400", "button_transition": "background-color 0.2s ease", "chatbot_code_background_color": "#FFFFFF", "chatbot_code_background_color_dark": "#000000", "checkbox_background_color": "#dce3e8", "checkbox_background_color_dark": "#242424", "checkbox_background_color_focus": "#dce3e8", "checkbox_background_color_focus_dark": "#242424", "checkbox_background_color_hover": "#dce3e8", "checkbox_background_color_hover_dark": "#242424", "checkbox_background_color_selected": "#4EACEF", "checkbox_background_color_selected_dark": "#4EACEF", "checkbox_border_color": "#dce3e8", "checkbox_border_color_dark": "#242424", "checkbox_border_color_focus": "#4EACEF", "checkbox_border_color_focus_dark": "#4EACEF", "checkbox_border_color_hover": "#4EACEF", "checkbox_border_color_hover_dark": "#4EACEF", "checkbox_border_color_selected": "#4EACEF", "checkbox_border_color_selected_dark": "#4EACEF", "checkbox_border_radius": "*radius_sm", "checkbox_border_width": "1px", "checkbox_border_width_dark": "1px", "checkbox_check": "url(\"data:image/svg+xml,%3csvg viewBox='0 0 16 16' fill='white' xmlns='http://www.w3.org/2000/svg'%3e%3cpath d='M12.207 4.793a1 1 0 010 1.414l-5 5a1 1 0 01-1.414 0l-2-2a1 1 0 011.414-1.414L6.5 9.086l4.293-4.293a1 1 0 011.414 0z'/%3e%3c/svg%3e\")", "checkbox_label_background_fill": "#ECF2F7", "checkbox_label_background_fill_dark": "#191919", "checkbox_label_background_fill_hover": "#dce3e8", "checkbox_label_background_fill_hover_dark": "#242424", "checkbox_label_background_fill_selected": "#dce3e8", "checkbox_label_background_fill_selected_dark": "#242424", "checkbox_label_border_color": "#dce3e8", "checkbox_label_border_color_dark": "#242424", "checkbox_label_border_color_hover": "#4EACEF", "checkbox_label_border_color_hover_dark": "#4EACEF", "checkbox_label_border_width": "1px", "checkbox_label_border_width_dark": "1px", "checkbox_label_gap": "*spacing_lg", "checkbox_label_padding": "*spacing_md calc(2 * *spacing_md)", "checkbox_label_shadow": "none", "checkbox_label_text_color": "#191919", "checkbox_label_text_color_dark": "#ECF2F7", "checkbox_label_text_color_selected": "#4EACEF", "checkbox_label_text_color_selected_dark": "#4EACEF", "checkbox_label_text_size": "*text_md", "checkbox_label_text_weight": "400", "checkbox_shadow": "*input_shadow", "color_accent": "*primary_500", "color_accent_soft": "#dce3e8", "color_accent_soft_dark": "#242424", "container_radius": "*radius_lg", "embed_radius": "*radius_lg", "error_background_fill": "#dce3e8", "error_background_fill_dark": "#242424", "error_border_color": "#191919", "error_border_color_dark": "#ECF2F7", "error_border_width": "1px", "error_border_width_dark": "1px", "error_icon_color": "#b91c1c", "error_icon_color_dark": "#ef4444", "error_text_color": "#4EACEF", "error_text_color_dark": "#4EACEF", "font": "'Asap', 'ui-sans-serif', sans-serif", "font_mono": "'Fira Code', 'ui-monospace', monospace", "form_gap_width": "0px", "input_background_fill": "#dce3e8", "input_background_fill_dark": "#242424", "input_background_fill_focus": "#dce3e8", "input_background_fill_focus_dark": "#242424", "input_background_fill_hover": "#d0d7db", "input_background_fill_hover_dark": "#202020", "input_border_color": "#191919", "input_border_color_dark": "#ECF2F7", "input_border_color_focus": "#191919", "input_border_color_focus_dark": "#ECF2F7", "input_border_color_hover": "#202020", "input_border_color_hover_dark": "#a1c3d8", "input_border_width": "0px", "input_padding": "*spacing_xl", "input_placeholder_color": "#19191930", "input_placeholder_color_dark": "#ECF2F730", "input_radius": "*radius_lg", "input_shadow": "#19191900", "input_shadow_dark": "#ECF2F700", "input_shadow_focus": "#19191900", "input_shadow_focus_dark": "#ECF2F700", "input_text_size": "*text_md", "input_text_weight": "400", "layout_gap": "*spacing_xxl", "link_text_color": "#4EACEF", "link_text_color_active": "#4EACEF", "link_text_color_active_dark": "#4EACEF", "link_text_color_dark": "#4EACEF", "link_text_color_hover": "#0c6ebd", "link_text_color_hover_dark": "#0c6ebd", "link_text_color_visited": "#4EACEF", "link_text_color_visited_dark": "#4EACEF", "loader_color": "#4EACEF", "loader_color_dark": "#4EACEF", "name": "base", "neutral_100": "#e2effc", "neutral_200": "#bedff9", "neutral_300": "#84c5f5", "neutral_400": "#4eacef", "neutral_50": "#f1f8fe", "neutral_500": "#198cde", "neutral_600": "#0c6ebd", "neutral_700": "#0b5899", "neutral_800": "#0e4b7e", "neutral_900": "#113f69", "neutral_950": "#0b2846", "panel_background_fill": "#ECF2F7", "panel_background_fill_dark": "#191919", "panel_border_color": "#4EACEF", "panel_border_color_dark": "#4EACEF", "panel_border_width": "0", "primary_100": "#e2effc", "primary_200": "#bedff9", "primary_300": "#84c5f5", "primary_400": "#4eacef", "primary_50": "#f1f8fe", "primary_500": "#198cde", "primary_600": "#0c6ebd", "primary_700": "#0b5899", "primary_800": "#0e4b7e", "primary_900": "#113f69", "primary_950": "#0b2846", "prose_header_text_weight": "600", "prose_text_size": "*text_md", "prose_text_weight": "400", "radio_circle": "url(\"data:image/svg+xml,%3csvg viewBox='0 0 16 16' fill='white' xmlns='http://www.w3.org/2000/svg'%3e%3ccircle cx='8' cy='8' r='3'/%3e%3c/svg%3e\")", "radius_lg": "8px", "radius_md": "6px", "radius_sm": "4px", "radius_xl": "12px", "radius_xs": "2px", "radius_xxl": "22px", "radius_xxs": "1px", "secondary_100": "#e2effc", "secondary_200": "#bedff9", "secondary_300": "#84c5f5", "secondary_400": "#4eacef", "secondary_50": "#f1f8fe", "secondary_500": "#198cde", "secondary_600": "#0c6ebd", "secondary_700": "#0b5899", "secondary_800": "#0e4b7e", "secondary_900": "#113f69", "secondary_950": "#0b2846", "section_header_text_size": "*text_md", "section_header_text_weight": "400", "shadow_drop": "rgba(0,0,0,0.05) 0px 1px 2px 0px", "shadow_drop_lg": "0 1px 3px 0 rgb(0 0 0 / 0.1), 0 1px 2px -1px rgb(0 0 0 / 0.1)", "shadow_inset": "rgba(0,0,0,0.05) 0px 2px 4px 0px inset", "shadow_spread": "#FFFFFF", "shadow_spread_dark": "#000000", "slider_color": "#4EACEF", "slider_color_dark": "#4EACEF", "spacing_lg": "8px", "spacing_md": "6px", "spacing_sm": "4px", "spacing_xl": "10px", "spacing_xs": "2px", "spacing_xxl": "16px", "spacing_xxs": "1px", "stat_background_fill": "#4EACEF", "stat_background_fill_dark": "#4EACEF", "table_border_color": "#191919", "table_border_color_dark": "#ECF2F7", "table_even_background_fill": "#ECF2F7", "table_even_background_fill_dark": "#191919", "table_odd_background_fill": "#dce3e8", "table_odd_background_fill_dark": "#242424", "table_radius": "*radius_lg", "table_row_focus": "#191919", "table_row_focus_dark": "#ECF2F7", "text_lg": "16px", "text_md": "14px", "text_sm": "12px", "text_xl": "22px", "text_xs": "10px", "text_xxl": "26px", "text_xxs": "9px"}, "version": "1.2.2"}