Upload 3 files

app.py

@@ -13,14 +13,16 @@ from auth import HuggingFaceAuth
 from benchmark_selection import BenchmarkSelector, create_benchmark_selection_ui
 from evaluation_queue import EvaluationQueue, create_model_submission_ui
 from leaderboard import Leaderboard, create_leaderboard_ui
+from model_config import ModelConfigManager, create_community_framework_ui
 from sample_benchmarks import add_sample_benchmarks
 
 # Initialize components in main thread
 db = DynamicHighscoresDB()
 auth_manager = HuggingFaceAuth(db)
 benchmark_selector = BenchmarkSelector(db, auth_manager)
-evaluation_queue = EvaluationQueue(db, auth_manager)
+evaluation_queue = EvaluationQueue(db, auth_manager, ModelConfigManager(db))
 leaderboard = Leaderboard(db)
+model_config_manager = ModelConfigManager(db)
 
 # Initialize sample benchmarks if none exist
 print("Checking for existing benchmarks...")
@@ -134,6 +136,7 @@ input[type="text"], input[type="password"], textarea {
 def js_login_script():
     space_host = os.environ.get("SPACE_HOST", "localhost:7860")
     redirect_uri = f"https://{space_host}"
+    client_id = os.environ.get("OAUTH_CLIENT_ID", "")
     
     return f"""
     <script src="https://unpkg.com/@huggingface/hub@0.13.0/dist/index.umd.min.js"></script>
@@ -155,6 +158,19 @@ def js_login_script():
                 document.getElementById("login-status").textContent = "Logged in as: " + oauthResult.userInfo.name;
                 document.getElementById("login-button").style.display = "none";
                 
+                // Add token to headers for future requests
+                const originalFetch = window.fetch;
+                window.fetch = function(url, options = {{}}) {{
+                    if (!options.headers) {{
+                        options.headers = {{}};
+                    }}
+                    
+                    // Add the token to the headers
+                    options.headers["HF-Token"] = oauthResult.accessToken;
+                    
+                    return originalFetch(url, options);
+                }};
+                
                 // Refresh the page to update server-side state
                 setTimeout(() => window.location.reload(), 1000);
             }}
@@ -164,29 +180,62 @@ def js_login_script():
         
         // Check if user is already logged in from localStorage
         const storedUser = localStorage.getItem("hf_user");
-        if (storedUser) {{
+        const storedToken = localStorage.getItem("hf_token");
+        
+        if (storedUser && storedToken) {{
             try {{
                 const userInfo = JSON.parse(storedUser);
                 document.getElementById("login-status").textContent = "Logged in as: " + userInfo.name;
                 document.getElementById("login-button").style.display = "none";
+                
+                // Add token to headers for future requests
+                const originalFetch = window.fetch;
+                window.fetch = function(url, options = {{}}) {{
+                    if (!options.headers) {{
+                        options.headers = {{}};
+                    }}
+                    
+                    // Add the token to the headers
+                    options.headers["HF-Token"] = storedToken;
+                    
+                    return originalFetch(url, options);
+                }};
             }} catch (e) {{
                 console.error("Error parsing stored user:", e);
             }}
         }}
         
         // Setup login button
-        document.getElementById("login-button").addEventListener("click", async function() {{
-            try {{
-                const loginUrl = await HfHub.oauthLoginUrl({{
-                    redirectUrl: "{redirect_uri}",
-                    scopes: ["openid", "profile"]
-                }});
-                window.location.href = loginUrl;
-            }} catch (error) {{
-                console.error("Error generating login URL:", error);
-                alert("Error starting login process. Please try again.");
-            }}
-        }});
+        const loginButton = document.getElementById("login-button");
+        if (loginButton) {{
+            loginButton.addEventListener("click", async function() {{
+                try {{
+                    const clientId = "{client_id}";
+                    if (clientId) {{
+                        // Use HuggingFace OAuth
+                        const loginUrl = await HfHub.oauthLoginUrl({{
+                            clientId: clientId,
+                            redirectUrl: "{redirect_uri}",
+                            scopes: ["openid", "profile"]
+                        }});
+                        console.log("Redirecting to:", loginUrl);
+                        window.location.href = loginUrl;
+                    }} else {{
+                        // Fallback to token-based login
+                        const token = prompt("Enter your HuggingFace token:");
+                        if (token) {{
+                            // Set the token as a cookie
+                            document.cookie = "hf_token=" + token + "; path=/; SameSite=Strict";
+                            // Reload the page to apply the token
+                            window.location.reload();
+                        }}
+                    }}
+                }} catch (error) {{
+                    console.error("Error starting login process:", error);
+                    alert("Error starting login process. Please try again.");
+                }}
+            }});
+        }}
     }})();
     </script>
     """
@@ -194,10 +243,11 @@ def js_login_script():
 # Simple manual authentication check
 def check_user(request: gr.Request):
     if request:
+        # Check for HF-User header from Space OAuth
         username = request.headers.get("HF-User")
         if username:
             # User is logged in via HF Spaces
-            print(f"User logged in: {username}")
+            print(f"User logged in via HF-User header: {username}")
             user = db.get_user_by_username(username)
             if not user:
                 # Create user if they don't exist
@@ -206,6 +256,20 @@ def check_user(request: gr.Request):
                 db.add_user(username, username, is_admin)
                 user = db.get_user_by_username(username)
             return username
+        
+        # Check for token in headers (from our custom JS)
+        token = request.headers.get("HF-Token")
+        if token:
+            try:
+                # Validate token with HuggingFace
+                user_info = auth_manager.hf_api.whoami(token=token)
+                if user_info:
+                    username = user_info.get("name", "")
+                    print(f"User logged in via token: {username}")
+                    return username
+            except Exception as e:
+                print(f"Token validation error: {e}")
+    
     return None
 
 # Start evaluation queue worker
@@ -238,7 +302,7 @@ with gr.Blocks(css=css, title="Dynamic Highscores") as app:
     
     gr.Markdown("# 🏆 Dynamic Highscores", elem_classes=["header"])
     gr.Markdown("""
-    *Not Active yet, Check back soon!* Welcome to Dynamic Highscores - a community benchmark platform for evaluating and comparing language models.
+    Welcome to Dynamic Highscores - a community benchmark platform for evaluating and comparing language models.
     
     - **Add your own benchmarks** from HuggingFace datasets
     - **Submit your models** for CPU-only evaluation
@@ -256,6 +320,9 @@ with gr.Blocks(css=css, title="Dynamic Highscores") as app:
         
         with gr.TabItem("🔍 Benchmarks", id=2):
             benchmark_ui = create_benchmark_selection_ui(benchmark_selector, auth_manager)
+        
+        with gr.TabItem("🌐 Community Framework", id=3):
+            community_ui = create_community_framework_ui(model_config_manager)
     
     gr.Markdown("""
     ### About Dynamic Highscores
@@ -281,4 +348,5 @@ if __name__ == "__main__":
     queue_thread.daemon = True
     queue_thread.start()
     
-    app.launch()
+    # Launch the app
+    app.launch()

auth.py

@@ -26,6 +26,18 @@ class HuggingFaceAuth:
         self.hf_api = HfApi()
         self.admin_username = os.environ.get("ADMIN_USERNAME", "Quazim0t0")
         self.running_in_space = 'SPACE_ID' in os.environ
+        
+        # OAuth configuration
+        self.client_id = os.environ.get("OAUTH_CLIENT_ID", "")
+        self.client_secret = os.environ.get("OAUTH_CLIENT_SECRET", "")
+        self.oauth_scopes = os.environ.get("OAUTH_SCOPES", "openid profile")
+        self.openid_provider_url = os.environ.get("OPENID_PROVIDER_URL", "https://huggingface.co")
+        
+        print(f"Running in Space: {self.running_in_space}")
+        if self.running_in_space:
+            print(f"OAuth Client ID: {self.client_id}")
+            print(f"OAuth Scopes: {self.oauth_scopes}")
+            print(f"OpenID Provider URL: {self.openid_provider_url}")
     
     def login_user(self, token):
         """Log in a user with their HuggingFace token.
@@ -89,6 +101,7 @@ class HuggingFaceAuth:
             # Check for HF-User header from Space OAuth
             username = request.headers.get("HF-User")
             if username:
+                print(f"Found HF-User header: {username}")
                 # Check if user exists in our database, create if not
                 user = self.db_manager.get_user_by_username(username)
                 if not user:
@@ -101,6 +114,10 @@ class HuggingFaceAuth:
         # Fallback to token-based auth for local development
         token = request.cookies.get("hf_token")
         
+        if not token:
+            # Try to get token from localStorage via headers
+            token = request.headers.get("HF-Token")
+            
         if not token:
             return None
         
@@ -223,6 +240,31 @@ class HuggingFaceAuth:
             user_id: User ID to update
         """
         self.db_manager.update_submission_date(user_id)
+    
+    def get_oauth_login_url(self, redirect_uri=None):
+        """Get the OAuth login URL for HuggingFace.
+        
+        Args:
+            redirect_uri: Redirect URI after login (optional)
+            
+        Returns:
+            str: OAuth login URL
+        """
+        if not self.client_id:
+            return None
+        
+        if not redirect_uri:
+            space_host = os.environ.get("SPACE_HOST", "localhost:7860")
+            redirect_uri = f"https://{space_host}"
+        
+        # Create a random state for security
+        state = os.urandom(16).hex()
+        
+        # Build the OAuth URL
+        scopes = self.oauth_scopes.replace(" ", "%20")
+        auth_url = f"{self.openid_provider_url}/oauth/authorize?client_id={self.client_id}&redirect_uri={redirect_uri}&scope={scopes}&state={state}&response_type=code"
+        
+        return auth_url
 
 # Authentication UI components
 def create_login_ui():
@@ -296,6 +338,9 @@ def logout_handler():
         <script>
         // Clear the token cookie
         document.cookie = "hf_token=; path=/; max-age=0; SameSite=Strict";
+        // Clear localStorage
+        localStorage.removeItem("hf_user");
+        localStorage.removeItem("hf_token");
         // Reload the page
         window.location.reload();
         </script>
@@ -323,4 +368,4 @@ def setup_auth_handlers(login_button, logout_button, user_info, auth_manager):
             fn=logout_handler,
             inputs=[],
             outputs=[login_button, logout_button, user_info, gr.HTML()]
-        )
+        )

model_config.py

@@ -1,8 +1,7 @@
 """
-Community framework documentation and model configuration system for Dynamic Highscores.
+Model configuration system for Dynamic Highscores.
 
-This module provides information about the framework and implements a modular
-system for model configurations.
+This module provides a modular system for model configurations.
 """
 
 import os
@@ -100,20 +99,21 @@ class ModelConfigManager:
         configs = []
         
         # Read all JSON files in the config directory
-        for filename in os.listdir(self.config_dir):
-            if filename.endswith(".json"):
-                config_path = os.path.join(self.config_dir, filename)
-                try:
-                    with open(config_path, "r") as f:
-                        config = json.load(f)
-                    
-                    # Add filename (without extension) as ID
-                    config_id = os.path.splitext(filename)[0]
-                    config["id"] = config_id
-                    
-                    configs.append(config)
-                except Exception as e:
-                    print(f"Error loading config {filename}: {e}")
+        if os.path.exists(self.config_dir):
+            for filename in os.listdir(self.config_dir):
+                if filename.endswith(".json"):
+                    config_path = os.path.join(self.config_dir, filename)
+                    try:
+                        with open(config_path, "r") as f:
+                            config = json.load(f)
+                        
+                        # Add filename (without extension) as ID
+                        config_id = os.path.splitext(filename)[0]
+                        config["id"] = config_id
+                        
+                        configs.append(config)
+                    except Exception as e:
+                        print(f"Error loading config {filename}: {e}")
         
         return configs
     
@@ -214,7 +214,7 @@ class ModelConfigManager:
             
             return True
         except Exception as e:
-            print(f"Error updating config {config_id}: {e}")
+            print(f"Error updating config: {e}")
             return False
     
     def delete_config(self, config_id):
@@ -227,31 +227,32 @@ class ModelConfigManager:
             bool: True if successful, False otherwise
         """
         try:
-            # Check if config exists
-            config_path = os.path.join(self.config_dir, f"{config_id}.json")
-            
-            if not os.path.exists(config_path):
+            # Check if this is a default config
+            if config_id in self.default_configs:
+                print(f"Cannot delete default config: {config_id}")
                 return False
             
             # Delete file
-            os.remove(config_path)
+            config_path = os.path.join(self.config_dir, f"{config_id}.json")
+            if os.path.exists(config_path):
+                os.remove(config_path)
+                return True
             
-            return True
+            return False
         except Exception as e:
-            print(f"Error deleting config {config_id}: {e}")
+            print(f"Error deleting config: {e}")
             return False
     
     def apply_config_to_model_params(self, model_params, config_id):
         """Apply a configuration to model parameters.
         
         Args:
-            model_params: Dictionary of model parameters
+            model_params: Dictionary of model parameters to update
             config_id: Configuration ID to apply
             
         Returns:
             dict: Updated model parameters
         """
-        # Get the configuration
         config = self.get_config(config_id)
         
         if not config or "parameters" not in config: