v0.2

README copy.md

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

README.md

@@ -1,12 +1 @@
----
-title: Arena
-emoji: 🐨
-colorFrom: indigo
-colorTo: red
-sdk: gradio
-sdk_version: 5.29.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# prompt-arena

app.py

@@ -1,176 +1,39 @@
 import gradio as gr
-import pandas as pd
 from arena import Arena
-import plotly.graph_objs as go
-import numpy as np
+import db
+from plot import plot_estimates_distribution
 
 LABEL_A = "Proposition A"
 LABEL_B = "Proposition B"
 
 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
+css_code = """
+/* Cible le premier bloc Markdown par son ID et lui donne un fond vert */
+#green_background input {
+    background-color: #41f707; /* Vert très clair */
+}
 
+/* Cible le second bloc Markdown par son ID et lui donne un fond rouge */
+#red_background input {
+    background-color: #FFCCCC
+}
+"""
 
-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>",
-            )
-        )
-        # 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",
-            )
-        )
-    fig.update_layout(
-        title="Distribution gaussienne de chaque prompt",
-        xaxis_title="Score (mu)",
-        yaxis_title="Densité",
-        template="plotly_white",
-        shapes=shapes,
-    )
-    return fig
-
+"""
+###############
+Gradio UI setup
+###############
+"""
 
 with gr.Blocks(
     title="Prompt Arena",
+    css=css_code,
     #    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)
+    match_state = gr.State()
+    user_state = gr.State()
+    timer = gr.Timer(1)
 
     gr.Markdown(
         '<h1 style="text-align:center;"> Concours du meilleur Prompt Engineer  </h1>'
@@ -181,120 +44,477 @@ with gr.Blocks(
         value=ARENA.get_progress(),
         interactive=False,
         lines=2,
+        visible=False,
     )
 
     with gr.Tabs() as tabs:
-        # Onglet des Combats
-        with gr.TabItem("Combats"):
+        """
+        ##################
+        Identification Tab
+        ##################
+        """
+        # Onglet Identification
+        with gr.TabItem("Identification", id=0) as identification_tab:
+            with gr.Row():
+                user_code_box = gr.Textbox(
+                    label="Code d'identification",
+                    placeholder="Saisissez votre code d'identification à 4 lettres",
+                    interactive=True,
+                    scale=0,
+                    min_width=250,
+                    max_lines=1,
+                )
+            validate_btn = gr.Button(
+                "Valider", variant="primary", scale=0, min_width=250
+            )
+            message = gr.Markdown("")
+
+        """
+        ###################### 
+        Identification Actions
+        ###################### 
+        """
+
+        @validate_btn.click(inputs=[user_code_box], outputs=[message, user_state])
+        def on_validate(code):
+            if not code or not code.strip():
+                return {
+                    message: gr.update(
+                        value="Veuillez entrer votre code d'identification.",
+                        visible=True,
+                    )
+                }
+            user = db.get_user(code)
+            if not user:
+                return {
+                    message: gr.update(
+                        value="Code invalide. Veuillez vérifier votre code d'identification.",
+                        visible=True,
+                    )
+                }
+            return {
+                message: gr.update(
+                    value=f"Code reconnu ! Bienvenue joueur {user['username']}",
+                    visible=True,
+                ),
+                user_state: user,
+            }
+
+        """
+        ##################
+        Candidate Tab
+        ##################
+        """
+
+        with gr.TabItem("Candidat", id=1, visible=False) as candidat_tab:
+            with gr.Row():
+                with gr.Column():
+                    label_input = gr.Markdown(value="Sujet du concours")
+                    competition_input = gr.Markdown(
+                        value=db.load("inputs")
+                        .query("name == 'Competition'")["text"]
+                        .values[0],
+                        container=True,
+                        max_height=100,
+                    )
+            with gr.Row():
+                with gr.Column():
+                    label_candidat = gr.Markdown(
+                        value="Votre candidat au concours",
+                    )
+                    candidat_prompt = gr.Textbox(
+                        show_label=False,
+                        placeholder="Saisissez votre texte candidat",
+                        interactive=True,
+                        scale=0,
+                        min_width=600,
+                        lines=10,
+                        max_lines=10,
+                    )
+                    submit_prompt_btn = gr.Button(
+                        "Valider", variant="primary", scale=0, min_width=250
+                    )
+
+                    message_prompt = gr.Markdown("", visible=False)
+
+                with gr.Column():
+                    label_preview = gr.Markdown(
+                        value="Aperçu du rendu (pour les contenus markdown ou html)",
+                        visible=False,
+                    )
+                    candidat_preview = gr.Markdown(
+                        value="", max_height=300, visible=False, container=True
+                    )
+
+        candidat_prompt.change(
+            lambda text: (
+                gr.update(value=text if text else "", visible=True if text else False),
+                gr.update(visible=True if text else False),
+            ),
+            inputs=candidat_prompt,
+            outputs=[candidat_preview, label_preview],
+        )
+
+        """
+        ##################
+        Compétition Tab
+        ##################
+        """
+
+        with gr.TabItem("Compétition", id=2, visible=False) as competition_tab:
             with gr.Row():
                 new_match_btn = gr.Button("Lancer un nouveau match", variant="primary")
 
             with gr.Row():
                 with gr.Column():
-                    proposition_a = gr.Textbox(label=LABEL_A, interactive=False)
-                    vote_a_btn = gr.Button("Choisir " + LABEL_A, interactive=False)
+                    label_prop_a = gr.Markdown(LABEL_A, visible=False)
+                    proposition_a = gr.Markdown(container=True, visible=False)
+                    vote_a_btn = gr.Button("Choisir " + LABEL_A, visible=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)
+                    label_prop_b = gr.Markdown(LABEL_B, visible=False)
+                    proposition_b = gr.Markdown(container=True, visible=False)
+                    vote_b_btn = gr.Button("Choisir " + LABEL_B, visible=False)
+            result = gr.Markdown("")
 
             #        with gr.TabItem("Classement"):
+
+        @new_match_btn.click(
+            inputs=[user_state],
+            outputs=[
+                label_prop_a,
+                label_prop_b,
+                proposition_a,
+                proposition_b,
+                match_state,
+                vote_a_btn,
+                vote_b_btn,
+                new_match_btn,
+                result,
+            ],
+        )
+        def select_and_display_match(user_state):
+            selected_match = ARENA.select_match(user_state)
+            if not selected_match:
+                return {
+                    label_prop_a: gr.update(visible=False),
+                    label_prop_b: gr.update(visible=False),
+                    proposition_a: gr.update(value="", visible=False),
+                    proposition_b: gr.update(value="", visible=False),
+                    match_state: {},
+                    vote_a_btn: gr.update(visible=False),
+                    vote_b_btn: gr.update(visible=False),
+                    new_match_btn: gr.update(visible=False),
+                    result: gr.update(
+                        value="Vous avez déjà voté pour tous les matchs disponibles. Veuillez attendre la fin de la compétition"
+                    ),
+                }
+            else:
+                prompt_a, prompt_b = selected_match
+                return {
+                    label_prop_a: gr.update(visible=True),
+                    label_prop_b: gr.update(visible=True),
+                    proposition_a: gr.update(value=prompt_a["text"], visible=True),
+                    proposition_b: gr.update(value=prompt_b["text"], visible=True),
+                    match_state: {
+                        "prompt_a_id": prompt_a["id"],
+                        "prompt_b_id": prompt_b["id"],
+                    },
+                    vote_a_btn: gr.update(visible=True),
+                    vote_b_btn: gr.update(visible=True),
+                    new_match_btn: gr.update(visible=False),
+                    result: gr.update(value=""),  # Reset result
+                }
+
+        @vote_a_btn.click(
+            inputs=[match_state, user_state],
+            outputs=[
+                result,
+                vote_a_btn,
+                vote_b_btn,
+                new_match_btn,
+            ],
+        )
+        def record_winner_a(match_state, user_state):
+            prompt_a_id = match_state["prompt_a_id"]
+            prompt_b_id = match_state["prompt_b_id"]
+            ARENA.record_result(prompt_a_id, prompt_b_id, user_state["id"])
+            return {
+                result: f"Vous avez choisi : {LABEL_A}",
+                vote_a_btn: gr.update(visible=False),
+                vote_b_btn: gr.update(visible=False),
+                new_match_btn: gr.update(visible=True),
+            }
+
+        @vote_b_btn.click(
+            inputs=[match_state, user_state],
+            outputs=[
+                result,
+                vote_a_btn,
+                vote_b_btn,
+                new_match_btn,
+            ],
+        )
+        def record_winner_b(match_state, user_state):
+            prompt_a_id = match_state["prompt_a_id"]
+            prompt_b_id = match_state["prompt_b_id"]
+            ARENA.record_result(prompt_b_id, prompt_a_id, user_state["id"])
+            return {
+                result: f"Vous avez choisi : {LABEL_B}",
+                vote_a_btn: gr.update(visible=False),
+                vote_b_btn: gr.update(visible=False),
+                new_match_btn: gr.update(visible=True),
+            }
+
+        """
+        ##################
+        Result Tab
+        ##################
+        """
+        with gr.TabItem("Classement") as result_tab:
             rankings_table = gr.DataFrame(
-                label="Classement des prompts",
+                label="Classement des équipes",
                 value=ARENA.get_rankings(),
                 interactive=True,
             )
 
-        # Onglet des Résultats
-        with gr.TabItem("Admin") as admin_tab:
+        """
+        ##################
+        Follow up Tab
+        ##################
+        """
+
+        with gr.TabItem("Followup") as admin_followup_tab:
+            with gr.Accordion("Matrice de compétition", open=False):
+                competition_matrix = gr.DataFrame(
+                    value=ARENA.get_competition_matrix(),
+                    interactive=True,
+                )
+            with gr.Accordion("Distribution des estimations", open=False):
+                plot_estimates = gr.Plot(
+                    plot_estimates_distribution,
+                    label="Distribution des estimations",
+                )
+
+        """
+        ##################
+        Database Tab
+        ##################
+        """
+        with gr.TabItem("Database") as admin_db_tab:
+            with gr.Accordion("Switches", open=False):
+                switches_table = gr.DataFrame(
+                    value=db.load("switches"),
+                    interactive=True,
+                )
+            with gr.Accordion("Inputs", open=False):
+                inputs_table = gr.DataFrame(
+                    value=db.load("inputs"),
+                    interactive=True,
+                )
             with gr.Accordion("Prompts", open=False):
                 prompts_table = gr.DataFrame(
-                    value=ARENA.load("prompts"),
+                    value=db.load("prompts"),
                     interactive=True,
                 )
             with gr.Accordion("Estimates", open=False):
                 estimates_table = gr.DataFrame(
                     label="Estimations",
-                    value=ARENA.load("estimates"),
+                    value=db.load("estimates"),
                     interactive=True,
                 )
             with gr.Accordion("Votes", open=False):
                 votes_table = gr.DataFrame(
                     label="Votes",
-                    value=ARENA.load("votes"),
+                    value=db.load("votes"),
+                    interactive=True,
+                )
+            with gr.Accordion("Teams", open=False):
+                teams_table = gr.DataFrame(
+                    label="Teams",
+                    value=db.load("teams"),
+                    interactive=True,
+                )
+            with gr.Accordion("Users", open=False):
+                users_table = gr.DataFrame(
+                    label="Users",
+                    value=db.load("users"),
                     interactive=True,
                 )
-            gr.Plot(plot_estimates_distribution, label="Distribution des estimations")
+
+            switches_table.change(
+                db.replace,
+                inputs=[gr.Markdown("switches", visible=False), switches_table],
+                outputs=None,
+            )
+            inputs_table.change(
+                db.replace,
+                inputs=[gr.Markdown("inputs", visible=False), inputs_table],
+                outputs=None,
+            )
             prompts_table.change(
-                update_table,
+                db.replace,
                 inputs=[gr.Markdown("prompts", visible=False), prompts_table],
                 outputs=None,
             )
             estimates_table.change(
-                update_table,
+                db.replace,
                 inputs=[gr.Markdown("estimates", visible=False), estimates_table],
                 outputs=None,
             )
             votes_table.change(
-                update_table,
+                db.replace,
                 inputs=[gr.Markdown("votes", visible=False), votes_table],
                 outputs=None,
             )
+            teams_table.change(
+                db.replace,
+                inputs=[gr.Markdown("teams", visible=False), teams_table],
+                outputs=None,
+            )
 
-    new_match_btn.click(
-        select_and_display_match,
-        inputs=[],
-        outputs=[
-            proposition_a,
-            proposition_b,
-            state,
-            vote_a_btn,
-            vote_b_btn,
-            new_match_btn,
-        ],
-    )
+            users_table.change(
+                db.replace,
+                inputs=[gr.Markdown("users", visible=False), users_table],
+                outputs=None,
+            )
 
-    # Callbacks pour les deux onglets
-    vote_a_btn.click(
-        record_winner_a,
-        inputs=[state],
+    """
+    ###################### 
+    Candidat Actions
+    ###################### 
+    """
+
+    @submit_prompt_btn.click(
+        inputs=[candidat_prompt, user_state],
         outputs=[
-            result,
-            progress_info,
-            rankings_table,
-            vote_a_btn,
-            vote_b_btn,
-            new_match_btn,
+            submit_prompt_btn,
+            candidat_prompt,
+            message_prompt,
+            competition_tab,
+            tabs,
         ],
     )
-    vote_b_btn.click(
-        record_winner_b,
-        inputs=[state],
-        outputs=[
-            result,
-            progress_info,
+    def submit_prompt(prompt_text, user_state):
+        if not prompt_text or not prompt_text.strip():
+            return {
+                message_prompt: gr.update(
+                    value="Veuillez saisir un prompt",
+                    visible=True,
+                ),
+            }
+        db_team_prompt = db.get_prompt(user_state["team"])
+        if db_team_prompt:
+            return {
+                submit_prompt_btn: gr.update(interactive=False),
+                candidat_prompt: gr.update(value=db_team_prompt, interactive=False),
+                message_prompt: gr.update(
+                    value="Votre équipe a déjà enregistré un candidat.",
+                    visible=True,
+                ),
+            }
+        db.insert("prompts", {"name": f"{user_state['team']}", "text": prompt_text})
+        # Initialize estimates for the newly submitted prompt
+        all_prompts = db.load("prompts")
+        prompt_id = all_prompts[all_prompts["name"] == user_state["team"]].iloc[0]["id"]
+        ARENA.init_estimates(prompt_id)
+        return {
+            submit_prompt_btn: gr.update(interactive=False),
+            candidat_prompt: gr.update(interactive=False),
+            message_prompt: gr.update(
+                value="Prompt soumis avec succès !", visible=True
+            ),
+            competition_tab: gr.update(visible=True),
+            tabs: gr.Tabs(selected=2),
+        }
+
+    """
+    ###################### 
+    Periodic refresh
+    ###################### 
+    """
+
+    def refresh(user_state):
+        if user_state is None:
+            return {
+                candidat_tab: gr.update(visible=False),
+                competition_tab: gr.update(visible=False),
+                result_tab: gr.update(visible=False),
+                admin_db_tab: gr.update(visible=False),
+                admin_followup_tab: gr.update(visible=False),
+            }
+
+        team = user_state.get("team", "")
+
+        update_prompt = {}
+        prompt_team = db.get_prompt(team)
+        if prompt_team:
+            update_prompt = {
+                candidat_prompt: gr.update(value=prompt_team, interactive=False),
+                submit_prompt_btn: gr.update(interactive=False, visible=False),
+                message_prompt: gr.update(
+                    value="Votre équipe a déjà enregistré un candidat.", visible=True
+                ),
+            }
+
+        update_tabs = {}
+        if user_state["team"] == "Admin":
+            update_tabs = {
+                candidat_tab: gr.update(visible=True),
+                competition_tab: gr.update(visible=True),
+                result_tab: gr.update(visible=True),
+                admin_db_tab: gr.update(visible=True),
+                admin_followup_tab: gr.update(visible=True),
+            }
+        else:
+            update_tabs = {
+                candidat_tab: gr.update(visible=db.get_status("Candidate")),
+                competition_tab: gr.update(visible=db.get_status("Competition")),
+                result_tab: gr.update(visible=db.get_status("Result")),
+                admin_db_tab: gr.update(visible=False),
+                admin_followup_tab: gr.update(visible=False),
+            }
+
+        update_tables = {
+            prompts_table: gr.update(value=db.load("prompts")),
+            estimates_table: gr.update(value=db.load("estimates")),
+            votes_table: gr.update(value=db.load("votes")),
+            teams_table: gr.update(value=db.load("teams")),
+            users_table: gr.update(value=db.load("users")),
+            competition_input: gr.update(
+                value=db.load("inputs").query("name == 'Competition'")["text"].values[0]
+            ),
+            plot_estimates: gr.update(value=plot_estimates_distribution()),
+            rankings_table: gr.update(value=ARENA.get_rankings()),
+            competition_matrix: gr.update(value=ARENA.get_competition_matrix()),
+        }
+
+        return {**update_prompt, **update_tabs, **update_tables}
+
+    timer.tick(
+        refresh,
+        [user_state],
+        [
+            prompts_table,
+            estimates_table,
+            votes_table,
+            teams_table,
+            users_table,
+            candidat_prompt,
+            submit_prompt_btn,
+            message_prompt,
+            candidat_tab,
+            competition_tab,
+            result_tab,
+            admin_db_tab,
+            admin_followup_tab,
+            plot_estimates,
             rankings_table,
-            vote_a_btn,
-            vote_b_btn,
-            new_match_btn,
+            competition_matrix,
+            competition_input,
         ],
     )
 
-    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__":
-    demo.launch(
-        auth_message="Connexion à l'arène des prompts"
-    )  # ajouter share=True pour partager l'interface
+    demo.launch()  # ajouter share=True pour partager l'interface

arena.py

@@ -1,7 +1,5 @@
 import trueskill as ts
 import pandas as pd
-import random
-import datetime
 from typing import Dict, List, Tuple, Union
 import db
 import pandas as pd
@@ -22,41 +20,28 @@ class Arena:
     Une arène pour comparer et classer des prompts en utilisant l'algorithme TrueSkill.
     """
 
-    def init_estimates(self, reboot=True) -> None:
+    def init_estimates(self, prompt_id) -> None:
         """
-        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.
+        Initialise les estimations d'un prompt avec des ratings TrueSkill par défaut.
         """
         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.
-        """
-        return db.load(table_name)
+        if prompt_id in estimates["prompt_id"].values:
+            # supprimer la ligne existante
+            db.delete(
+                "estimates",
+                int(estimates[estimates["prompt_id"] == prompt_id].iloc[0].id),
+            )
 
-    def replace(self, table_name: str, df: pd.DataFrame) -> pd.DataFrame:
-        """
-        fonction back pour l'UI.
-        Remplace le contenu d'une table par les données du fichier CSV.
-        Pour l'admin uniquement
-        """
-        return db.replace(table_name, df)
+        db.insert(
+            "estimates",
+            {
+                "prompt_id": prompt_id,
+                "mu": MU_init,
+                "sigma": SIGMA_init,
+            },
+        )
 
-    def select_match(self) -> Tuple[Prompt, Prompt]:
+    def select_match(self, user_state) -> Tuple[Prompt, Prompt] | None:
         """
         Sélectionne deux prompts pour un match en privilégiant ceux avec une grande incertitude.
         Returns:
@@ -64,31 +49,62 @@ class Arena:
         """
         # 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]
+        # retirer le prompt de l'utilisateur pour qu'il ne puisse pas voter pour son propre prompt
+        estimates = estimates[
+            estimates["prompt_id"] != db.get_prompt_id(user_state["team"])
+        ]
+
+        def order_match(id_a, id_b):
+            """Return a tuple of ids ordered by the id."""
+            return (id_a, id_b) if id_a < id_b else (id_b, id_a)
+
+        # les matchs possibles entre les prompts par ordre d'incertitude décroissant
+        matches = (
+            estimates.merge(estimates, how="cross", suffixes=["_a", "_b"])
+            .query("id_a != id_b")
+            .assign(delta_mu=lambda df_: abs(df_["mu_a"] - df_["mu_b"]))
+            .sort_values(by=["sigma_a", "delta_mu"], ascending=[False, True])
+            .assign(
+                match=lambda df_: df_.apply(
+                    lambda row: order_match(int(row["id_a"]), int(row["id_b"])), axis=1
+                )
+            )
         )
 
-        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)
+        user_votes = db.load("votes").loc[
+            lambda df_: df_["user_id"] == user_state["id"]
+        ]
+
+        if user_votes.empty:
+            user_votes = user_votes.assign(match=[])
+        else:  # les votes de l'utilisateur
+            user_votes = user_votes.assign(
+                match=lambda df_: df_.apply(
+                    lambda row: order_match(
+                        int(row["winner_id"]), int(row["loser_id"])
+                    ),
+                    axis=1,
+                )
+            )
 
-        # 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]))
+        # on ne garde que les matchs qui n'ont pas encore été votés par l'utilisateur
+        user_matches = matches.loc[~matches["match"].isin(user_votes["match"])]
 
+        if user_matches.empty:
+            # Si l'utilisateur a déjà voté sur tous les matchs, on ne peut pas en sélectionner de nouveaux
+            return None
+
+        selected_match = user_matches.iloc[0]
+        prompts = db.load("prompts")
+        prompt_a = (
+            prompts.query(f"id == {selected_match['prompt_id_a']}").iloc[0].to_dict()
+        )
+        prompt_b = (
+            prompts.query(f"id == {selected_match['prompt_id_b']}").iloc[0].to_dict()
+        )
         return prompt_a, prompt_b
 
-    def record_result(self, winner_id: str, loser_id: str) -> None:
+    def record_result(self, winner_id: str, loser_id: str, user_id: str) -> None:
         # Obtenir les ratings actuels
         estimates = db.load("estimates")
         winner_estimate = (
@@ -117,6 +133,7 @@ class Arena:
             {
                 "winner_id": winner_id,
                 "loser_id": loser_id,
+                "user_id": user_id,
                 #                "timestamp": datetime.datetime.now().isoformat(),
             },
         )
@@ -137,8 +154,56 @@ class Arena:
         rankings = prompts.merge(estimates, left_on="id", right_on="prompt_id").drop(
             columns=["id", "prompt_id"]
         )
-        return rankings.sort_values(by="mu", ascending=False)
+        rankings = rankings.sort_values(by="mu", ascending=False)
+        # ajouter un colonne position
+        rankings["position"] = range(1, len(rankings) + 1)
+
         # eventuellement afficher plutôt mu - 3 sigma pour être conservateur
+        # rankings["score"] = rankings["mu"] - 3 * rankings["sigma"]
+        return rankings[["position", "team"]]
+
+    def get_competition_matrix(self) -> pd.DataFrame:
+        """
+        Obtient la matrice de combats des prompts.
+
+        Returns:
+            DataFrame contenant en ligne et en colonne les noms d'équipes,
+            et dans la cellule le pourcentage de victoires de l'équipe de la ligne contre l'équipe de la colonne.
+        """
+
+        prompts = db.load("prompts")
+        votes = db.load("votes")
+
+        competition_matrix = pd.DataFrame(
+            index=prompts["team"], columns=prompts["team"], data=0
+        )
+        competition_matrix.index.name = None
+        competition_matrix.columns.name = None
+
+        wins = competition_matrix.copy()
+        matches = competition_matrix.copy()
+
+        for _, row in votes.iterrows():
+            winner_name = prompts.loc[prompts["id"] == row["winner_id"], "team"].values[
+                0
+            ]
+            loser_name = prompts.loc[prompts["id"] == row["loser_id"], "team"].values[0]
+            wins.at[winner_name, loser_name] += 1
+            matches.at[winner_name, loser_name] += 1
+            matches.at[loser_name, winner_name] += 1
+
+        competition_matrix = wins.div(matches)
+
+        competition_matrix = competition_matrix.map(
+            lambda x: "" if pd.isna(x) or x == 0 else f"{x:.0%}"
+        )
+
+        for i in range(len(competition_matrix)):
+            competition_matrix.iloc[i, i] = "X"
+
+        competition_matrix = competition_matrix.replace("", "?").reset_index(names="")
+
+        return competition_matrix
 
     def get_progress(self) -> str:
         """

database/estimates.csv

@@ -1,6 +1 @@
 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/inputs.csv

@@ -0,0 +1,2 @@
+id,name,text
+1,Competition,"Insérer le sujet de la compétition"

database/prompts.csv

@@ -1,6 +1 @@
-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
+id,team,text

database/switches.csv

@@ -0,0 +1,5 @@
+id,name,status
+1,Candidate,0
+2,Competition,0
+3,Result,0
+4,Admin,0

database/teams.csv

@@ -0,0 +1,16 @@
+id,name
+1,Rock
+2,Pop
+3,Jazz
+4,Blues
+5,Salsa
+6,Reggae
+7,Disco
+8,Tango
+9,Soul
+10,Rap
+11,Techno
+12,Folk
+13,Bossa
+14,Country
+15,Gospel

database/users.csv

@@ -0,0 +1,47 @@
+id,team,username,code
+0,Admin,Admin,MSTR
+1,Rock,Rock 1,BGSN
+2,Rock,Rock 2,SGEF
+3,Rock,Rock 3,RSET
+4,Pop,Pop 1,BHWQ
+5,Pop,Pop 2,GEGX
+6,Pop,Pop 3,WTRR
+7,Jazz,Jazz 1,FZBH
+8,Jazz,Jazz 2,SZUO
+9,Jazz,Jazz 3,JCCO
+10,Blues,Blues 1,WKTP
+11,Blues,Blues 2,DAOA
+12,Blues,Blues 3,EEPL
+13,Salsa,Salsa 1,OZPN
+14,Salsa,Salsa 2,REBM
+15,Salsa,Salsa 3,DKAH
+16,Reggae,Reggae 1,VUCY
+17,Reggae,Reggae 2,VISH
+18,Reggae,Reggae 3,RWAG
+19,Disco,Disco 1,PXRJ
+20,Disco,Disco 2,JJQL
+21,Disco,Disco 3,HNUT
+22,Tango,Tango 1,MHBJ
+23,Tango,Tango 2,BSLF
+24,Tango,Tango 3,XNKK
+25,Soul,Soul 1,IZGQ
+26,Soul,Soul 2,OUGL
+27,Soul,Soul 3,XEAO
+28,Rap,Rap 1,CYMX
+29,Rap,Rap 2,WAFZ
+30,Rap,Rap 3,BPIR
+31,Techno,Techno 1,TMCY
+32,Techno,Techno 2,TXMK
+33,Techno,Techno 3,NVUO
+34,Folk,Folk 1,ZATS
+35,Folk,Folk 2,LNWA
+36,Folk,Folk 3,HOKK
+37,Bossa,Bossa 1,FWQM
+38,Bossa,Bossa 2,UKWF
+39,Bossa,Bossa 3,EHDR
+40,Country,Country 1,MKHF
+41,Country,Country 2,UGCW
+42,Country,Country 3,KBSO
+43,Gospel,Gospel 1,IZJB
+44,Gospel,Gospel 2,HIJK
+45,Gospel,Gospel 3,JSNN

database/votes.csv

@@ -1,11 +1 @@
-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
+id,winner_id,loser_id,user_id

db.py

@@ -12,7 +12,7 @@ Pour être à jour des mises à jours des autres utilisateurs, il faut recharger
 DATABASE = {
     "prompts": {
         "filename": "database/prompts.csv",
-        "columns": ["id", "name", "text"],
+        "columns": ["id", "team", "text"],
     },
     "estimates": {
         "filename": "database/estimates.csv",
@@ -22,6 +22,22 @@ DATABASE = {
         "filename": "database/votes.csv",
         "columns": ["id", "winner_id", "loser_id"],
     },
+    "teams": {
+        "filename": "database/teams.csv",
+        "columns": ["id", "name"],
+    },
+    "users": {
+        "filename": "database/users.csv",
+        "columns": ["id", "team", "username", "code"],
+    },
+    "switches": {
+        "filename": "database/switches.csv",
+        "columns": ["id", "name", "status"],
+    },
+    "inputs": {
+        "filename": "database/inputs.csv",
+        "columns": ["id", "name", "text"],
+    },
 }
 
 
@@ -53,10 +69,22 @@ def update(table_name: str, row_id: int, data: dict) -> None:
     """
     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)
+    if idx.empty:
+        idx = len(df)
+    for key, value in data.items():
+        df.loc[idx, key] = value
+    df.to_csv(DATABASE[table_name]["filename"], index=False)
+
+
+def delete(table_name: str, id: int) -> None:
+    """
+    Supprime une ligne de la table spécifiée par son id.
+    Exemple :
+        db.delete("prompts", 5)
+    """
+    df = load(table_name)
+    df = df[df["id"] != id]
+    df.to_csv(DATABASE[table_name]["filename"], index=False)
 
 
 def replace(table_name: str, df: pd.DataFrame) -> None:
@@ -66,3 +94,59 @@ def replace(table_name: str, df: pd.DataFrame) -> None:
         db.replace("prompts", df)
     """
     df.to_csv(DATABASE[table_name]["filename"], index=False)
+
+
+def get_prompt(team: str) -> str | None:
+    """
+    Retourne le prompt de l'équipe spécifiée.
+    Si l'équipe n'a pas de prompt, retourne une chaîne vide.
+    """
+    prompts_df = load("prompts")
+    row = prompts_df[prompts_df["team"] == team]
+    if not row.empty:
+        return row.iloc[0]["text"]
+    return None
+
+
+def get_prompt_id(team: str) -> str | None:
+    """
+    Retourne le prompt de l'équipe spécifiée.
+    Si l'équipe n'a pas de prompt, retourne une chaîne vide.
+    """
+    prompts_df = load("prompts")
+    row = prompts_df[prompts_df["team"] == team]
+    if not row.empty:
+        return row.iloc[0]["id"]
+    return None
+
+
+def get_status(name: str) -> bool:
+    """
+    Retourne le statut du switch spécifié.
+    Si le nom du switch n'existe pas en base, retourne 0.
+    """
+    switches_df = load("switches")
+    row = switches_df[switches_df["name"] == name]
+    if not row.empty:
+        return bool(int(row.fillna(0).iloc[0]["status"]))
+    return False
+
+
+def set_status(name: str, status: int) -> None:
+    """
+    Met à jour le statut du switch spécifié.
+    Si le nom du switch n'existe pas, l'ajoute avec le statut donné.
+    """
+    switches_df = load("switches")
+    switches_df.loc[switches_df["name"] == name, "status"] = status
+    replace("switches", switches_df)
+
+
+def get_user(code: str) -> dict | None:
+    """
+    Retourne les informations de l'utilisateur si le code est valide.
+    Si le code est invalide, retourne None.
+    """
+    users_df = load("users")
+    row = users_df.loc[users_df["code"] == code, ["id", "team", "username"]]
+    return row.to_dict(orient="records")[0] if not row.empty else None

plot.py

@@ -0,0 +1,68 @@
+import db
+import numpy as np
+import plotly.graph_objects as go
+
+
+def plot_estimates_distribution():
+    """Affiche une gaussienne par prompt (Plotly) + lignes verticales pointillées sur les moyennes."""
+    estimates = db.load("estimates")
+    prompts = db.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>",
+            )
+        )
+        # 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",
+            )
+        )
+    fig.update_layout(
+        title="Distribution gaussienne de chaque prompt",
+        xaxis_title="Score (mu)",
+        yaxis_title="Densité",
+        template="plotly_white",
+        shapes=shapes,
+    )
+    return fig

poetry.lock

@@ -2019,6 +2019,70 @@ httpx = "*"
 [package.extras]
 dev = ["pytest"]
 
+[[package]]
+name = "scipy"
+version = "1.15.3"
+description = "Fundamental algorithms for scientific computing in Python"
+optional = false
+python-versions = ">=3.10"
+groups = ["main"]
+files = [
+    {file = "scipy-1.15.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:a345928c86d535060c9c2b25e71e87c39ab2f22fc96e9636bd74d1dbf9de448c"},
+    {file = "scipy-1.15.3-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:ad3432cb0f9ed87477a8d97f03b763fd1d57709f1bbde3c9369b1dff5503b253"},
+    {file = "scipy-1.15.3-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:aef683a9ae6eb00728a542b796f52a5477b78252edede72b8327a886ab63293f"},
+    {file = "scipy-1.15.3-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:1c832e1bd78dea67d5c16f786681b28dd695a8cb1fb90af2e27580d3d0967e92"},
+    {file = "scipy-1.15.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:263961f658ce2165bbd7b99fa5135195c3a12d9bef045345016b8b50c315cb82"},
+    {file = "scipy-1.15.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e2abc762b0811e09a0d3258abee2d98e0c703eee49464ce0069590846f31d40"},
+    {file = "scipy-1.15.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ed7284b21a7a0c8f1b6e5977ac05396c0d008b89e05498c8b7e8f4a1423bba0e"},
+    {file = "scipy-1.15.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5380741e53df2c566f4d234b100a484b420af85deb39ea35a1cc1be84ff53a5c"},
+    {file = "scipy-1.15.3-cp310-cp310-win_amd64.whl", hash = "sha256:9d61e97b186a57350f6d6fd72640f9e99d5a4a2b8fbf4b9ee9a841eab327dc13"},
+    {file = "scipy-1.15.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:993439ce220d25e3696d1b23b233dd010169b62f6456488567e830654ee37a6b"},
+    {file = "scipy-1.15.3-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:34716e281f181a02341ddeaad584205bd2fd3c242063bd3423d61ac259ca7eba"},
+    {file = "scipy-1.15.3-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3b0334816afb8b91dab859281b1b9786934392aa3d527cd847e41bb6f45bee65"},
+    {file = "scipy-1.15.3-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:6db907c7368e3092e24919b5e31c76998b0ce1684d51a90943cb0ed1b4ffd6c1"},
+    {file = "scipy-1.15.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:721d6b4ef5dc82ca8968c25b111e307083d7ca9091bc38163fb89243e85e3889"},
+    {file = "scipy-1.15.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:39cb9c62e471b1bb3750066ecc3a3f3052b37751c7c3dfd0fd7e48900ed52982"},
+    {file = "scipy-1.15.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:795c46999bae845966368a3c013e0e00947932d68e235702b5c3f6ea799aa8c9"},
+    {file = "scipy-1.15.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:18aaacb735ab38b38db42cb01f6b92a2d0d4b6aabefeb07f02849e47f8fb3594"},
+    {file = "scipy-1.15.3-cp311-cp311-win_amd64.whl", hash = "sha256:ae48a786a28412d744c62fd7816a4118ef97e5be0bee968ce8f0a2fba7acf3bb"},
+    {file = "scipy-1.15.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6ac6310fdbfb7aa6612408bd2f07295bcbd3fda00d2d702178434751fe48e019"},
+    {file = "scipy-1.15.3-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:185cd3d6d05ca4b44a8f1595af87f9c372bb6acf9c808e99aa3e9aa03bd98cf6"},
+    {file = "scipy-1.15.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:05dc6abcd105e1a29f95eada46d4a3f251743cfd7d3ae8ddb4088047f24ea477"},
+    {file = "scipy-1.15.3-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:06efcba926324df1696931a57a176c80848ccd67ce6ad020c810736bfd58eb1c"},
+    {file = "scipy-1.15.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c05045d8b9bfd807ee1b9f38761993297b10b245f012b11b13b91ba8945f7e45"},
+    {file = "scipy-1.15.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:271e3713e645149ea5ea3e97b57fdab61ce61333f97cfae392c28ba786f9bb49"},
+    {file = "scipy-1.15.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6cfd56fc1a8e53f6e89ba3a7a7251f7396412d655bca2aa5611c8ec9a6784a1e"},
+    {file = "scipy-1.15.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0ff17c0bb1cb32952c09217d8d1eed9b53d1463e5f1dd6052c7857f83127d539"},
+    {file = "scipy-1.15.3-cp312-cp312-win_amd64.whl", hash = "sha256:52092bc0472cfd17df49ff17e70624345efece4e1a12b23783a1ac59a1b728ed"},
+    {file = "scipy-1.15.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:2c620736bcc334782e24d173c0fdbb7590a0a436d2fdf39310a8902505008759"},
+    {file = "scipy-1.15.3-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:7e11270a000969409d37ed399585ee530b9ef6aa99d50c019de4cb01e8e54e62"},
+    {file = "scipy-1.15.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:8c9ed3ba2c8a2ce098163a9bdb26f891746d02136995df25227a20e71c396ebb"},
+    {file = "scipy-1.15.3-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:0bdd905264c0c9cfa74a4772cdb2070171790381a5c4d312c973382fc6eaf730"},
+    {file = "scipy-1.15.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:79167bba085c31f38603e11a267d862957cbb3ce018d8b38f79ac043bc92d825"},
+    {file = "scipy-1.15.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c9deabd6d547aee2c9a81dee6cc96c6d7e9a9b1953f74850c179f91fdc729cb7"},
+    {file = "scipy-1.15.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:dde4fc32993071ac0c7dd2d82569e544f0bdaff66269cb475e0f369adad13f11"},
+    {file = "scipy-1.15.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f77f853d584e72e874d87357ad70f44b437331507d1c311457bed8ed2b956126"},
+    {file = "scipy-1.15.3-cp313-cp313-win_amd64.whl", hash = "sha256:b90ab29d0c37ec9bf55424c064312930ca5f4bde15ee8619ee44e69319aab163"},
+    {file = "scipy-1.15.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:3ac07623267feb3ae308487c260ac684b32ea35fd81e12845039952f558047b8"},
+    {file = "scipy-1.15.3-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:6487aa99c2a3d509a5227d9a5e889ff05830a06b2ce08ec30df6d79db5fcd5c5"},
+    {file = "scipy-1.15.3-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:50f9e62461c95d933d5c5ef4a1f2ebf9a2b4e83b0db374cb3f1de104d935922e"},
+    {file = "scipy-1.15.3-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:14ed70039d182f411ffc74789a16df3835e05dc469b898233a245cdfd7f162cb"},
+    {file = "scipy-1.15.3-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a769105537aa07a69468a0eefcd121be52006db61cdd8cac8a0e68980bbb723"},
+    {file = "scipy-1.15.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9db984639887e3dffb3928d118145ffe40eff2fa40cb241a306ec57c219ebbbb"},
+    {file = "scipy-1.15.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:40e54d5c7e7ebf1aa596c374c49fa3135f04648a0caabcb66c52884b943f02b4"},
+    {file = "scipy-1.15.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:5e721fed53187e71d0ccf382b6bf977644c533e506c4d33c3fb24de89f5c3ed5"},
+    {file = "scipy-1.15.3-cp313-cp313t-win_amd64.whl", hash = "sha256:76ad1fb5f8752eabf0fa02e4cc0336b4e8f021e2d5f061ed37d6d264db35e3ca"},
+    {file = "scipy-1.15.3.tar.gz", hash = "sha256:eae3cf522bc7df64b42cad3925c876e1b0b6c35c1337c93e12c0f366f55b0eaf"},
+]
+
+[package.dependencies]
+numpy = ">=1.23.5,<2.5"
+
+[package.extras]
+dev = ["cython-lint (>=0.12.2)", "doit (>=0.36.0)", "mypy (==1.10.0)", "pycodestyle", "pydevtool", "rich-click", "ruff (>=0.0.292)", "types-psutil", "typing_extensions"]
+doc = ["intersphinx_registry", "jupyterlite-pyodide-kernel", "jupyterlite-sphinx (>=0.19.1)", "jupytext", "matplotlib (>=3.5)", "myst-nb", "numpydoc", "pooch", "pydata-sphinx-theme (>=0.15.2)", "sphinx (>=5.0.0,<8.0.0)", "sphinx-copybutton", "sphinx-design (>=0.4.0)"]
+test = ["Cython", "array-api-strict (>=2.0,<2.1.1)", "asv", "gmpy2", "hypothesis (>=6.30)", "meson", "mpmath", "ninja ; sys_platform != \"emscripten\"", "pooch", "pytest", "pytest-cov", "pytest-timeout", "pytest-xdist", "scikit-umfpack", "threadpoolctl"]
+
 [[package]]
 name = "semantic-version"
 version = "2.10.0"
@@ -2110,6 +2174,18 @@ anyio = ">=3.6.2,<5"
 [package.extras]
 full = ["httpx (>=0.27.0,<0.29.0)", "itsdangerous", "jinja2", "python-multipart (>=0.0.18)", "pyyaml"]
 
+[[package]]
+name = "tinydb"
+version = "4.8.2"
+description = "TinyDB is a tiny, document oriented database optimized for your happiness :)"
+optional = false
+python-versions = "<4.0,>=3.8"
+groups = ["main"]
+files = [
+    {file = "tinydb-4.8.2-py3-none-any.whl", hash = "sha256:f97030ee5cbc91eeadd1d7af07ab0e48ceb04aa63d4a983adbaca4cba16e86c3"},
+    {file = "tinydb-4.8.2.tar.gz", hash = "sha256:f7dfc39b8d7fda7a1ca62a8dbb449ffd340a117c1206b68c50b1a481fb95181d"},
+]
+
 [[package]]
 name = "tomlkit"
 version = "0.13.3"
@@ -2386,4 +2462,4 @@ files = [
 [metadata]
 lock-version = "2.1"
 python-versions = ">=3.12,<4.0"
-content-hash = "f76406c4e9dc01fbaacdfcb31eb2cb78221ae89bc68a1d961b2841e6670f9ec4"
+content-hash = "e5d2bd5217695205ea0868e860217189bd487dd86a49d59a14ee98051186cf32"

prompts.csv

@@ -1,5 +0,0 @@
-Prompt A 100
-Prompt B 90
-Prompt C 60
-Prompt D 55
-Prompt E 30

pyproject.toml

@@ -11,7 +11,7 @@ dependencies = [
     "trueskill (>=0.4.5,<0.5.0)",
     "gradio (>=4.0.0)",
     "pandas (>=2.0.0)",
-    "plotly (>=6.1.2,<7.0.0)",
+    "plotly (>=6.1.2,<7.0.0)"
 ]
 
 

routes.py

@@ -1,7 +0,0 @@
-@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