User managed solution for a new tournament creation

app.py

@@ -288,6 +288,33 @@ def enable_submit_buttons():
         gr.update(interactive=True),
     )
 
+def results_dataset_integrity_check():
+    leaderboard_server.results_dataset_integrity_check(solve=True)
+
+def on_tournament_results_corrupted():
+    if leaderboard_server.tournament_results_corrupted and not leaderboard_server.tournament_results_integrity_solving:
+        results_dataset_integrity_check_btn = gr.update(
+            interactive=True,
+            visible=True,
+        )
+        results_dataset_integrity_solving_progress = gr.update(
+            visible=False,
+        )
+    else:
+        results_dataset_integrity_check_btn = gr.update(
+            interactive=False,
+            visible=False,
+        )
+        results_dataset_integrity_solving_progress = gr.update(
+            value=leaderboard_server.tournament_results_integrity_solving_progress * 100,
+            visible=True,
+        )
+    
+    return (
+        results_dataset_integrity_check_btn,
+        results_dataset_integrity_solving_progress,
+    )
+
 def on_application_load():
     with leaderboard_server.var_lock.ro:
         leaderboard = gr.update(
@@ -340,7 +367,57 @@ tr.row_odd {
 def gradio_app():
     with gr.Blocks(theme=gr.themes.Soft(text_size=text_md), css=custom_css) as main:
         gr.Markdown(HEADER_MARKDOWN)
-
+        
+        if leaderboard_server.tournament_results_corrupted:
+            results_dataset_integrity_check_btn = gr.Button(
+                value='Check integrity of results dataset',
+                interactive=True,
+                visible=False,
+            )
+            
+            results_dataset_integrity_solving_progress = gr.Slider(
+                minimum=0,
+                maximum=100,
+                value=leaderboard_server.tournament_results_integrity_solving_progress * 100,
+                label="Tournament results is preparing, please wait…",
+                interactive=False,
+                visible=False,
+            )
+            
+            results_dataset_integrity_solving_progress_timer = gr.Timer(
+                value=2,
+            )
+            
+            results_dataset_integrity_solving_progress_timer.tick(
+                fn=lambda: gr.update(
+                    value=leaderboard_server.tournament_results_integrity_solving_progress * 100
+                ),
+                outputs=results_dataset_integrity_solving_progress
+            )
+            
+            results_dataset_integrity_check_btn.click(
+                fn=lambda: (
+                    gr.update(interactive=False, visible=False),
+                    gr.update(visible=True),
+                ),
+                outputs=[
+                    results_dataset_integrity_check_btn,
+                    results_dataset_integrity_solving_progress,
+                ]
+            ).then(
+                fn=results_dataset_integrity_check
+            )
+            
+            main.load(
+                fn=on_tournament_results_corrupted,
+                outputs=[
+                    results_dataset_integrity_check_btn,
+                    results_dataset_integrity_solving_progress,
+                ]
+            )
+            
+            return main
+        
         with gr.Tabs():
             with leaderboard_server.var_lock.ro:
                 submission_ids_and_titles = get_submission_ids_and_titles()

server.py

@@ -187,6 +187,9 @@ class LeaderboardServer:
         self.submission_id_to_model_title = {}
         self.submission_id_to_data = {}  # Only data (results and metadata) using by leaderboard
         self.tournament_results = None
+        self.tournament_results_corrupted = False
+        self.tournament_results_integrity_solving = False
+        self.tournament_results_integrity_solving_progress = 0
         
         self.leaderboard_dataframes = {}  # For each category
         self.tournament_dataframes = {}  # For each submission_id and category
@@ -223,7 +226,7 @@ class LeaderboardServer:
         categories = [self.TASKS_CATEGORY_OVERALL] + sorted(self.TASKS_CATEGORIES)
         
         leaderboard_dataframes = {
-            category: self._get_leaderboard(category=category)
+            category: self._get_leaderboard(category=category) if not self.tournament_results_corrupted else pd.DataFrame(columns=['Corrupted, please check integrity'])
             for category in categories
         }
         
@@ -232,7 +235,7 @@ class LeaderboardServer:
         
         tournament_dataframes = {
             submission_id: {
-                category: self._get_model_tournament_table(submission_id, category)
+                category: self._get_model_tournament_table(submission_id, category) if not self.tournament_results_corrupted else pd.DataFrame(columns=['Corrupted, please check integrity'])
                 for category in categories
             }
             for submission_id in submission_ids
@@ -243,7 +246,10 @@ class LeaderboardServer:
             self.tournament_dataframes = tournament_dataframes
         
         leaderboard_dataframes_csv = {
-            category: self._dataframe_to_csv(self._get_leaderboard(category=category, to_csv=True), f"Leaderboard - {category}.csv")
+            category: self._dataframe_to_csv(
+                self._get_leaderboard(category=category, to_csv=True) if not self.tournament_results_corrupted else pd.DataFrame(columns=['Corrupted, please check integrity']),
+                f"Leaderboard - {category}.csv"
+            )
             for category in categories
         }
         
@@ -251,7 +257,7 @@ class LeaderboardServer:
             tournament_dataframes_csv = {
                 submission_id: {
                     category: self._dataframe_to_csv(
-                        self._get_model_tournament_table(submission_id, category, to_csv=True),
+                        self._get_model_tournament_table(submission_id, category, to_csv=True) if not self.tournament_results_corrupted else pd.DataFrame(columns=['Corrupted, please check integrity']),
                         f"Tournament table - {self.submission_id_to_data[submission_id]['submission_metadata']['model_name'][:self.MAX_LENGTH_OF_MODEL_TITLE].replace('/', '_')} - {category}.csv",
                     )
                     for category in sorted(self.TASKS_CATEGORIES)
@@ -326,7 +332,7 @@ class LeaderboardServer:
             self.submission_id_to_model_title = submission_id_to_model_title
             self.submission_id_to_data = submission_id_to_data
 
-    def results_dataset_integrity_check(self):
+    def results_dataset_integrity_check(self, solve=False):
         """
         Zkontroluje, že:
         - všechny modely byly v duelu se všemi
@@ -361,31 +367,48 @@ class LeaderboardServer:
                         ):
                             pass
                         else:
+                            self.tournament_results_corrupted = False
                             break
-
-                    renew_tournament_began_datetime = datetime.now(timezone.utc)
-                    datetime2str = lambda d: d.strftime("%Y-%m-%dT%H:%M:%S %Z")
-                    print(f"Renew tournament began at {datetime2str(renew_tournament_began_datetime)}")
-                    gr.Info('Running tournament...', duration=15)
-                    with self.var_lock.rw:
-                        self.tournament_results = {}
-                        submission_ids_backup = self.submission_ids
-                        self.submission_ids = set()
-                    for submission_id in submission_ids_backup:
-                        with self.var_lock.ro:
-                            file = self.submission_id_to_file[submission_id]
-                            tournament_results = self.start_tournament(submission_id, file)
-                        with self.var_lock.rw:
-                            self.tournament_results = tournament_results
-                            self.submission_ids.add(submission_id)
-                    renew_tournament_ended_datetime = datetime.now(timezone.utc)
-                    print(f"Renew tournament ended at {datetime2str(renew_tournament_ended_datetime)}")
-                    renew_tournament_ended_time_elapsed = renew_tournament_ended_datetime - renew_tournament_began_datetime
-                    print(f"Time elapsed: {renew_tournament_ended_time_elapsed}")
                     
-                    gr.Info('Uploading tournament results...', duration=5)
-                    if self.tournament_results:
-                        self._upload_tournament_results(self.tournament_results)
+                    if solve:
+                        self.tournament_results_integrity_solving = True
+                        self.tournament_results_integrity_solving_progress = 0
+                        
+                        renew_tournament_began_datetime = datetime.now(timezone.utc)
+                        datetime2str = lambda d: d.strftime("%Y-%m-%dT%H:%M:%S %Z")
+                        print(f"Renew tournament began at {datetime2str(renew_tournament_began_datetime)}")
+                        gr.Info('Running tournament...', duration=15)
+                        
+                        with self.var_lock.rw:
+                            self.tournament_results = {}
+                            submission_ids_backup = self.submission_ids
+                            self.submission_ids = set()
+                        
+                        for i, submission_id in enumerate(submission_ids_backup):
+                            self.tournament_results_integrity_solving_progress = i / len(submission_ids_backup)
+                            
+                            with self.var_lock.ro:
+                                file = self.submission_id_to_file[submission_id]
+                                tournament_results = self.start_tournament(submission_id, file)
+                            with self.var_lock.rw:
+                                self.tournament_results = tournament_results
+                                self.submission_ids.add(submission_id)
+                        
+                        self.tournament_results_integrity_solving_progress = 1
+                        
+                        renew_tournament_ended_datetime = datetime.now(timezone.utc)
+                        print(f"Renew tournament ended at {datetime2str(renew_tournament_ended_datetime)}")
+                        renew_tournament_ended_time_elapsed = renew_tournament_ended_datetime - renew_tournament_began_datetime
+                        print(f"Time elapsed: {renew_tournament_ended_time_elapsed}")
+                        
+                        gr.Info('Uploading tournament results...', duration=5)
+                        if self.tournament_results:
+                            self._upload_tournament_results(self.tournament_results)
+                        
+                        self.tournament_results_integrity_solving = False
+                        self.tournament_results_corrupted = False
+                    else:
+                        self.tournament_results_corrupted = True
                     
                     break
             gr.Info("Waiting in queue...", duration=5)