Locks only on confirmation of submission

app.py

@@ -1,5 +1,6 @@
 import os
 
+import json
 import regex as re
 import gradio as gr
 from gradio.themes.utils.sizes import text_md
@@ -181,8 +182,12 @@ def get_submission_ids_and_titles():
     
     return submission_ids_and_titles
 
-def submit_results():
-    leaderboard_server.save_pre_submit()
+def submit_results(*inputs):
+    inputs = dict(zip(SUBMISSION_INPUTS, inputs))
+    with open(inputs["submission_file"]) as fp:
+        data = json.load(fp)
+    metadata = data["submission_metadata"]
+    leaderboard_server.save_model_submission(inputs["submission_file"], metadata)
     gr.Info('Submission successful!')
     
     with leaderboard_server.var_lock.ro:
@@ -215,10 +220,14 @@ def submit_results():
     )
 
 
-def erase_pre_submit():
-    with leaderboard_server.pre_submit_lock:
-        if leaderboard_server.pre_submit:
-            leaderboard_server.pre_submit = None  # NOTE: Is it safe? How to confirm that `submission_id` is equal?
+def erase_pre_submit(*inputs):
+    inputs = dict(zip(SUBMISSION_INPUTS, inputs))
+    with open(inputs["submission_file"]) as fp:
+        data = json.load(fp)
+    metadata = data["submission_metadata"]
+    submission_id = metadata["submission_id"]
+    leaderboard_server.pre_submit.pop(submission_id)
+    
     return (
         gr.update(value='Pre-submit model', visible=True, interactive=True),
         gr.update(visible=False),
@@ -908,6 +917,13 @@ def gradio_app():
                     pre_submission_btn.click(
                         fn=on_submit_pressed,
                         outputs=[pre_submission_btn],
+                    ).then(
+                        fn=lambda *inputs: tuple(
+                            gr.update(interactive=False)
+                            for _ in inputs
+                        ),
+                        inputs=list(submission_inputs.values()),
+                        outputs=list(submission_inputs.values()),
                     ).then(
                         fn=process_submission,
                         inputs=list(submission_inputs.values()),
@@ -938,6 +954,7 @@ def gradio_app():
                         ]
                     ).then(
                         fn=submit_results,
+                        inputs=list(submission_inputs.values()),
                         outputs=[
                             pre_submission_btn,
                             submission_btn_yes,
@@ -961,6 +978,13 @@ def gradio_app():
                             modal_submit_yes,
                             modal_submit_no,
                         ]
+                    ).then(
+                        fn=lambda *inputs: tuple(
+                            gr.update(interactive=True)
+                            for _ in inputs
+                        ),
+                        inputs=list(submission_inputs.values()),
+                        outputs=list(submission_inputs.values()),
                     )
 
                     modal_submit_no.click(
@@ -982,6 +1006,7 @@ def gradio_app():
 
                     submission_btn_no.click(
                         fn=erase_pre_submit,
+                        inputs=list(submission_inputs.values()),
                         outputs=[
                             pre_submission_btn,
                             submission_btn_yes,
@@ -993,6 +1018,13 @@ def gradio_app():
                             pre_submit_model_tournament_results_table,
                             pre_submit_model_tournament_results_table_csv,
                         ],
+                    ).then(
+                        fn=lambda *inputs: tuple(
+                            gr.update(interactive=True)
+                            for _ in inputs
+                        ),
+                        inputs=list(submission_inputs.values()),
+                        outputs=list(submission_inputs.values()),
                     )
             
             with gr.TabItem('About'):

server.py

@@ -167,6 +167,19 @@ def check_significance(model_a_path, model_b_path):
     result = check_significance_wait_for_result(result_url)
     return result
 
+class NoneLock:
+    def __init__(self, *args, **kwargs):
+        pass
+    
+    def __enter__(self):
+        return True
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return
+    
+    def __call__(self, *args, **kwargs):
+        return NoneLock(*args, **kwargs)
+
 class TimeoutLock:
     def __init__(self, lock=None, timeout=-1):
         self.lock = lock or Lock()
@@ -187,8 +200,6 @@ class TimeoutLock:
     def __call__(self, timeout):
         return TimeoutLock(lock=self.lock, timeout=timeout)
 
-pre_submit_lock = TimeoutLock()
-
 class _ReadLock:
     def __init__(self, lock):
        self._lock = lock
@@ -259,8 +270,8 @@ class LeaderboardServer:
         self.results_dataset_local_snapshot_lock = ReadWriteLock()
         self.results_dataset_local_snapshot = None
         
-        self.pre_submit_lock = pre_submit_lock
-        self.pre_submit = None
+        self.pre_submit = {}
+        self.submit_lock = TimeoutLock()
         
         self.results_dataset_integrity_check()  # Check integrity of the results dataset after (re)start Hugging Face Space
         self.update_leaderboard()
@@ -410,8 +421,8 @@ class LeaderboardServer:
         """
         
         while True:
-            with self.pre_submit_lock(timeout=5) as acquired:
-                if acquired and self.pre_submit == None:
+            with self.submit_lock(timeout=5) as acquired:
+                if acquired:
                     gr.Info('Checking integrity...', duration=15)
                     self._update_models_and_tournament_results()
                     
@@ -765,6 +776,13 @@ class LeaderboardServer:
     def start_tournament(self, new_submission_id, new_model_file):
         with self.var_lock.ro:
             new_tournament = copy.deepcopy(self.tournament_results)
+            
+            pre_submit = self.pre_submit.get(new_submission_id)
+            if pre_submit:
+                new_tournament[new_submission_id] = pre_submit.tournament_results[new_submission_id]
+                for competitor_id in pre_submit.tournament_results[new_submission_id].keys() - {new_submission_id}:
+                    new_tournament[competitor_id][new_submission_id] = pre_submit.tournament_results[competitor_id][new_submission_id]
+            
             if new_submission_id not in new_tournament:
                 new_tournament[new_submission_id] = {}
                 new_tournament[new_submission_id][new_submission_id] = {
@@ -849,7 +867,7 @@ class LeaderboardServer:
         return result
     
     PreSubmit = namedtuple('PreSubmit', 'tournament_results, submission_id, file, data')
-    
+
     def prepare_model_for_submission(self, file, metadata) -> PreSubmit:
         with open(file, "r") as f:
             data = json.load(f)
@@ -867,17 +885,35 @@ class LeaderboardServer:
         with open(file, "w") as f:
             json.dump(data, f, separators=(',', ':'))  # compact JSON
         
+        return self._prepare_model_for_submission(file, metadata, do_submit=False)
+
+    def save_model_submission(self, file, metadata) -> PreSubmit:
+        return self._prepare_model_for_submission(file, metadata, do_submit=True)
+
+    def _prepare_model_for_submission(self, file, metadata, do_submit=False) -> PreSubmit:
+        with open(file, "r") as f:
+            data = json.load(f)
+        
+        submission_id = metadata["submission_id"]
+        
         while True:
-            with self.pre_submit_lock(timeout=5) as acquired:
-                if acquired and self.pre_submit == None:
-                    gr.Info('Running tournament...', duration=15)
+            submit_lock = self.submit_lock if do_submit else NoneLock()
+            
+            with submit_lock(timeout=5) as acquired:
+                if acquired:
+                    info_msg = 'Running tournament...'
+                    gr.Info(info_msg, duration=15)
+                    if do_submit:
+                        print(f"Locked `submit_lock` for {submission_id = }")
+                        print(info_msg)
+                        
                     self.update_leaderboard()
                     if HF_FAKE_TOURNAMENT:
                         with self.var_lock.ro:
                             tournament_results = copy.deepcopy(self.tournament_results)
                     else:
                         tournament_results = self.start_tournament(submission_id, file)
-                    self.pre_submit = self.PreSubmit(
+                    pre_submit = self.PreSubmit(
                         tournament_results,
                         submission_id,
                         file,
@@ -887,22 +923,19 @@ class LeaderboardServer:
                             "submission_metadata": metadata,
                         }
                     )
+                    self.pre_submit[submission_id] = pre_submit
+                    
+                    if do_submit:
+                        self._upload_submission(pre_submit.submission_id, pre_submit.file)
+                        self._upload_tournament_results(pre_submit.tournament_results)
+                        self.update_leaderboard()
+                        print(f"Unlocked `submit_lock` for {submission_id = }")
+                    
                     break
             gr.Info("Waiting in queue...", duration=5)
             time.sleep(10)
         
-        return self.pre_submit
-
-    def save_pre_submit(self):
-        with self.pre_submit_lock:
-            if self.pre_submit:
-                tournament_results, submission_id, file, data = self.pre_submit
-                
-                self._upload_submission(submission_id, file)
-                self._upload_tournament_results(tournament_results)
-                
-                self.pre_submit = None
-                self.update_leaderboard()
+        return pre_submit
 
     def _upload_submission_id_to_model_title(self):
         # Temporary save tournament results