Update app.py

app.py

@@ -8,6 +8,7 @@ import pandas as pd
 from filelock import FileLock, Timeout
 from pathlib import Path
 import tempfile
+import uuid
 
 
 class VideoArenaManager:
@@ -18,6 +19,7 @@ class VideoArenaManager:
         self.data_file = "/data/arena_data.json"  # Combined data file
         self.data_lock = FileLock("/data/arena_data.lock")  # Single lock file
         self.data = self._load_data()  # Load Elo ratings and results
+        self.current_username = self.generate_random_username()
 
     def _load_models(self) -> List[Dict[str, str]]:
         """Load available models from directories."""
@@ -89,12 +91,13 @@ class VideoArenaManager:
                     results = {"comparisons": []}
                     self.data = {"elo_ratings": elo_ratings, "results": results}
 
-                # Update comparison results
+                # Update comparison results with username
                 comparison = {
                     "timestamp": datetime.now().isoformat(),
                     "video": video_name,
                     "winner": winner,
                     "loser": loser,
+                    "username": self.current_username,
                 }
                 self.data["results"]["comparisons"].append(comparison)
 
@@ -141,81 +144,92 @@ class VideoArenaManager:
         """Get video paths for the given pair of models."""
         return [os.path.join(self.base_dir, model["directory"], video_name) for model in model_pair]
 
+    def generate_random_username(self) -> str:
+        """Generate a random username."""
+        return f"user_{uuid.uuid4().hex[:8]}"
+
 
 def create_arena_interface():
     manager = VideoArenaManager()
+    ADMIN_KEY = "keyface"  # Choose your secret key
 
     with gr.Blocks(title="Video Model Ranking Arena") as demo:
-        gr.Markdown(
-            "# Video Model Ranking Arena\n\nCompare generated videos and help determine which model performs best!"
-        )
+        gr.Markdown("# Video Model Ranking Arena")
+        gr.Markdown("Choose which video looks better!")
 
-        # State variables
-        current_video = gr.State()
-        current_models = gr.State()
+        # Add a hidden admin key input - make sure it has a unique class
+        with gr.Row(visible=False, elem_classes="admin-row") as admin_row:
+            admin_input = gr.Textbox(label="Admin Key", type="password", container=False, elem_classes="admin-input")
 
         with gr.Row():
-            # Display two videos side by side
-            video_left = gr.Video(label="Model A", height=400)
-            video_right = gr.Video(label="Model B", height=400)
+            video_left = gr.Video(label="Option A", interactive=False)
+            video_right = gr.Video(label="Option B", interactive=False)
 
         with gr.Row():
-            # Buttons for voting
-            left_button = gr.Button("👈 Left video looks better", size="lg")
-            right_button = gr.Button("Right video looks better 👉", size="lg")
-
-        # Create a Tabbed Interface
-        with gr.Tabs():
-            # Tab for the main video comparison interface
-            with gr.Tab("Video Comparison"):
-                pass  # Placeholder for the comparison UI
-
-            # Tab for displaying current rankings
-            with gr.Tab("Current Rankings"):
-                rankings_table = gr.DataFrame(
-                    manager.get_rankings(),
-                    label="Current Model Rankings",
-                    headers=["Model", "Elo Rating"],
-                    interactive=False,
-                )
-
-        def load_new_comparison():
-            """Load a new random comparison."""
-            video_name = random.choice(manager.videos)
-            model_pair = manager.get_random_pair()
-            video_paths = manager.get_video_paths(video_name, model_pair)
-
-            # Update video labels
-            video_left.label = model_pair[0]["name"]
-            video_right.label = model_pair[1]["name"]
-
-            current_video_value = video_name
-            current_models_value = [model["name"] for model in model_pair]
-
-            return (
-                video_paths[0],  # video_left
-                video_paths[1],  # video_right
-                current_video_value,  # current_video
-                current_models_value,  # current_models
-                manager.get_rankings(),  # rankings_table
-            )
+            left_button = gr.Button("Choose Left (A)", size="lg")
+            right_button = gr.Button("Choose Right (B)", size="lg")
+
+        # Hidden state management
+        current_video = gr.State("")
+        current_models = gr.State([])
+
+        # Rankings display
+        rankings_table = gr.Dataframe(
+            headers=["Model", "Rating"],
+            label="Current Rankings",
+        )
+
+        # Add this CSS and JS to handle the admin functionality
+        demo.load(
+            None,
+            None,
+            _js="""
+            function() {
+                // Hide download button by default
+                const downloadBtn = document.querySelector('.download-button');
+                if (downloadBtn) {
+                    downloadBtn.style.setProperty('display', 'none', 'important');
+                }
+                
+                // Add keyboard shortcut listener for admin panel
+                document.addEventListener('keydown', function(e) {
+                    // Check for Ctrl+Shift+K
+                    if (e.ctrlKey && e.shiftKey && e.key === 'K') {
+                        const adminRow = document.querySelector('.admin-row');
+                        if (adminRow) {
+                            adminRow.style.display = adminRow.style.display === 'none' ? 'block' : 'none';
+                        }
+                    }
+                });
+
+                // Add input listener for admin key
+                const adminInput = document.querySelector('.admin-input input');
+                if (adminInput) {
+                    adminInput.addEventListener('input', function(e) {
+                        const downloadBtn = document.querySelector('.download-button');
+                        if (downloadBtn) {
+                            if (e.target.value === 'your_secret_key_here') {
+                                downloadBtn.style.setProperty('display', 'block', 'important');
+                            } else {
+                                downloadBtn.style.setProperty('display', 'none', 'important');
+                            }
+                        }
+                    });
+                }
+            }
+        """.replace("your_secret_key_here", ADMIN_KEY),
+        )  # Inject the admin key securely
 
         def handle_choice(choice_index: int, video_name: str, current_models_value: List[str]):
-            """Handle the user's choice and update rankings."""
             if not current_models_value or len(current_models_value) < 2:
                 print("Error: current_models is invalid:", current_models_value)
                 return gr.update(visible=False), gr.update(visible=False), "", [], manager.get_rankings()
 
             winner = current_models_value[choice_index]
             loser = current_models_value[1 - choice_index]
-
-            # Save the comparison result
             manager.save_comparison(video_name, winner, loser)
-
-            # Load new comparison
             return load_new_comparison()
 
-        # Button click handlers
         left_button.click(
             fn=lambda vid, models: handle_choice(0, vid, models),
             inputs=[current_video, current_models],
@@ -240,10 +254,10 @@ def create_arena_interface():
             ],
         )
 
-        # Initial load
+        # Load initial comparison
         demo.load(
             fn=load_new_comparison,
-            inputs=[],
+            inputs=None,
             outputs=[
                 video_left,
                 video_right,
@@ -253,37 +267,6 @@ def create_arena_interface():
             ],
         )
 
-        # File management section with collapsible download option
-        gr.Markdown("## Download Results File (Optional)")
-
-        with gr.Accordion("Download Results File", open=False):
-            files = manager.get_data_files()
-            file_names = [file["name"] for file in files]
-            file_select = gr.Dropdown(choices=file_names, label="Select Results File to Download", interactive=True)
-            download_button = gr.Button("Download Selected File", size="sm")  # Smaller button
-
-        def download_file(file_name: str):
-            """Prepare the selected file for download."""
-            if not file_name:
-                return None
-
-            file_path = f"/data/{file_name}"
-            try:
-                # Create a temporary file to handle the download
-                with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(file_name)[1]) as tmp_file:
-                    with open(file_path, "rb") as f:
-                        tmp_file.write(f.read())
-                    return tmp_file.name
-            except Exception as e:
-                print(f"Error preparing download: {e}")
-                return None
-
-        download_button.click(
-            fn=download_file,
-            inputs=[file_select],
-            outputs=gr.File(label="Download"),
-        )
-
     return demo