update

app.py

@@ -3,6 +3,7 @@ from gradio_leaderboard import Leaderboard, ColumnFilter, SelectColumns
 import pandas as pd
 from apscheduler.schedulers.background import BackgroundScheduler
 from huggingface_hub import snapshot_download
+import os
 
 from src.about import (
     CITATION_BUTTON_LABEL,
@@ -24,33 +25,62 @@ from src.display.utils import (
     Language,
     AssessmentStatus
 )
-from src.envs import API, EVAL_REQUESTS_PATH, EVAL_RESULTS_PATH, QUEUE_REPO, REPO_ID, RESULTS_REPO, TOKEN
+from src.envs import API, EVAL_REQUESTS_PATH, EVAL_RESULTS_PATH, QUEUE_REPO, REPO_ID, RESULTS_REPO, TOKEN, LOCAL_MODE
 from src.populate import get_evaluation_queue_df, get_leaderboard_df
 from src.submission.submit import add_new_eval
 
 
 def restart_space():
-    API.restart_space(repo_id=REPO_ID)
+    """Restart the Hugging Face space"""
+    if LOCAL_MODE:
+        print("Running in local mode, skipping space restart")
+        return
+        
+    try:
+        API.restart_space(repo_id=REPO_ID)
+    except Exception as e:
+        print(f"Failed to restart space: {e}")
+        print("Continuing without restart")
 
 ### Space initialisation
-try:
-    print(EVAL_REQUESTS_PATH)
-    snapshot_download(
-        repo_id=QUEUE_REPO, local_dir=EVAL_REQUESTS_PATH, repo_type="dataset", tqdm_class=None, etag_timeout=30, token=TOKEN
-    )
-except Exception:
-    restart_space()
-try:
-    print(EVAL_RESULTS_PATH)
-    snapshot_download(
-        repo_id=RESULTS_REPO, local_dir=EVAL_RESULTS_PATH, repo_type="dataset", tqdm_class=None, etag_timeout=30, token=TOKEN
-    )
-except Exception:
-    restart_space()
-
-
+def initialize_data_directories():
+    """Initialize directories for assessment data"""
+    # Create local directories if they don't exist
+    os.makedirs(EVAL_REQUESTS_PATH, exist_ok=True)
+    os.makedirs(EVAL_RESULTS_PATH, exist_ok=True)
+    
+    if LOCAL_MODE:
+        print("Running in local mode, using local directories only")
+        return
+    
+    # Try to download from HF if not in local mode
+    try:
+        print(f"Downloading request data from {QUEUE_REPO} to {EVAL_REQUESTS_PATH}")
+        snapshot_download(
+            repo_id=QUEUE_REPO, local_dir=EVAL_REQUESTS_PATH, repo_type="dataset", 
+            tqdm_class=None, etag_timeout=30, token=TOKEN
+        )
+    except Exception as e:
+        print(f"Failed to download request data: {e}")
+        print("Using local data only")
+    
+    try:
+        print(f"Downloading result data from {RESULTS_REPO} to {EVAL_RESULTS_PATH}")
+        snapshot_download(
+            repo_id=RESULTS_REPO, local_dir=EVAL_RESULTS_PATH, repo_type="dataset", 
+            tqdm_class=None, etag_timeout=30, token=TOKEN
+        )
+    except Exception as e:
+        print(f"Failed to download result data: {e}")
+        print("Using local data only")
+
+# Initialize data
+initialize_data_directories()
+
+# Load data for leaderboard
 LEADERBOARD_DF = get_leaderboard_df(EVAL_RESULTS_PATH, EVAL_REQUESTS_PATH, COLS, BENCHMARK_COLS)
 
+# Load queue data
 (
     finished_eval_queue_df,
     running_eval_queue_df,
@@ -58,8 +88,13 @@ LEADERBOARD_DF = get_leaderboard_df(EVAL_RESULTS_PATH, EVAL_REQUESTS_PATH, COLS,
 ) = get_evaluation_queue_df(EVAL_REQUESTS_PATH, EVAL_COLS)
 
 def init_leaderboard(dataframe):
+    """Initialize the leaderboard component"""
     if dataframe is None or dataframe.empty:
-        raise ValueError("Leaderboard DataFrame is empty or None.")
+        # Create an empty dataframe with the expected columns
+        empty_df = pd.DataFrame(columns=COLS)
+        print("Warning: Leaderboard DataFrame is empty. Using empty dataframe.")
+        dataframe = empty_df
+        
     return Leaderboard(
         value=dataframe,
         datatype=[c.type for c in fields(AutoEvalColumn)],
@@ -192,7 +227,11 @@ with demo:
                 show_copy_button=True,
             )
 
-scheduler = BackgroundScheduler()
-scheduler.add_job(restart_space, "interval", seconds=1800)
-scheduler.start()
+# Only schedule space restarts if not in local mode
+if not LOCAL_MODE:
+    scheduler = BackgroundScheduler()
+    scheduler.add_job(restart_space, "interval", seconds=1800)
+    scheduler.start()
+
+# Launch the app
 demo.queue(default_concurrency_limit=40).launch()

assessment-queue/langchain-ai_langchain_request.json

@@ -0,0 +1,14 @@
+{
+  "library": "langchain-ai/langchain",
+  "version": "v0.1.0",
+  "repository_url": "https://github.com/langchain-ai/langchain",
+  "language": "Python",
+  "framework": "Python SDK",
+  "library_type": "llm framework",
+  "license": "MIT",
+  "stars": 74500,
+  "status": "FINISHED",
+  "submitted_time": "2025-04-30T10:00:00Z",
+  "last_updated": "2025-05-01T12:00:00Z",
+  "assessment_id": "abc123"
+}

assessment-queue/microsoft_autogen_request.json

@@ -0,0 +1,14 @@
+{
+  "library": "microsoft/autogen",
+  "version": "v0.2.0",
+  "repository_url": "https://github.com/microsoft/autogen",
+  "language": "Python",
+  "framework": "Agent Framework",
+  "library_type": "agent framework",
+  "license": "MIT",
+  "stars": 48700,
+  "status": "FINISHED",
+  "submitted_time": "2025-05-02T08:15:00Z",
+  "last_updated": "2025-05-03T09:15:00Z",
+  "assessment_id": "ghi789"
+}

assessment-queue/pytorch_pytorch_request.json

@@ -0,0 +1,14 @@
+{
+  "library": "pytorch/pytorch",
+  "version": "v2.1.0",
+  "repository_url": "https://github.com/pytorch/pytorch",
+  "language": "Python",
+  "framework": "Machine Learning",
+  "library_type": "machine learning",
+  "license": "BSD-3",
+  "stars": 72300,
+  "status": "FINISHED",
+  "submitted_time": "2025-05-01T16:30:00Z",
+  "last_updated": "2025-05-02T14:30:00Z",
+  "assessment_id": "def456"
+}

assessment-results/sample_assessment.json

@@ -0,0 +1,46 @@
+{
+  "assessment": {
+    "library_name": "langchain-ai/langchain",
+    "version": "v0.1.0",
+    "language": "Python",
+    "framework": "Python SDK",
+    "completed_time": "2025-05-01T12:00:00Z",
+    "last_updated": "2025-05-01T12:00:00Z",
+    "active_maintenance": true,
+    "independently_verified": true,
+    "scores": {
+      "license_validation": 2.5,
+      "security_assessment": 4.8,
+      "maintenance_health": 1.2,
+      "dependency_management": 3.7,
+      "regulatory_compliance": 5.2
+    },
+    "details": {
+      "license_validation": {
+        "license_type": "MIT",
+        "compatibility": "High",
+        "issues": "None"
+      },
+      "security_assessment": {
+        "known_vulnerabilities": 3,
+        "patch_responsiveness": "Medium",
+        "last_security_review": "2025-03-15"
+      },
+      "maintenance_health": {
+        "active_contributors": 42,
+        "release_frequency": "High",
+        "issue_response_time": "1.2 days"
+      },
+      "dependency_management": {
+        "vulnerable_dependencies": 2,
+        "dependency_freshness": "Good",
+        "supply_chain_security": "Medium"
+      },
+      "regulatory_compliance": {
+        "documentation_quality": "Medium",
+        "data_privacy_features": "Basic",
+        "audit_readiness": "Low"
+      }
+    }
+  }
+}

assessment-results/sample_assessment2.json

@@ -0,0 +1,46 @@
+{
+  "assessment": {
+    "library_name": "pytorch/pytorch",
+    "version": "v2.1.0",
+    "language": "Python",
+    "framework": "Machine Learning",
+    "completed_time": "2025-05-02T14:30:00Z",
+    "last_updated": "2025-05-02T14:30:00Z",
+    "active_maintenance": true,
+    "independently_verified": false,
+    "scores": {
+      "license_validation": 1.8,
+      "security_assessment": 3.2,
+      "maintenance_health": 2.0,
+      "dependency_management": 2.5,
+      "regulatory_compliance": 4.1
+    },
+    "details": {
+      "license_validation": {
+        "license_type": "BSD-3",
+        "compatibility": "High",
+        "issues": "None"
+      },
+      "security_assessment": {
+        "known_vulnerabilities": 2,
+        "patch_responsiveness": "High",
+        "last_security_review": "2025-04-10"
+      },
+      "maintenance_health": {
+        "active_contributors": 156,
+        "release_frequency": "Medium",
+        "issue_response_time": "2.5 days"
+      },
+      "dependency_management": {
+        "vulnerable_dependencies": 1,
+        "dependency_freshness": "Very Good",
+        "supply_chain_security": "High"
+      },
+      "regulatory_compliance": {
+        "documentation_quality": "High",
+        "data_privacy_features": "Medium",
+        "audit_readiness": "Medium"
+      }
+    }
+  }
+}

assessment-results/sample_assessment3.json

@@ -0,0 +1,46 @@
+{
+  "assessment": {
+    "library_name": "microsoft/autogen",
+    "version": "v0.2.0",
+    "language": "Python",
+    "framework": "Agent Framework",
+    "completed_time": "2025-05-03T09:15:00Z",
+    "last_updated": "2025-05-03T09:15:00Z",
+    "active_maintenance": true,
+    "independently_verified": true,
+    "scores": {
+      "license_validation": 3.1,
+      "security_assessment": 6.7,
+      "maintenance_health": 2.8,
+      "dependency_management": 5.5,
+      "regulatory_compliance": 7.2
+    },
+    "details": {
+      "license_validation": {
+        "license_type": "MIT",
+        "compatibility": "High",
+        "issues": "None"
+      },
+      "security_assessment": {
+        "known_vulnerabilities": 5,
+        "patch_responsiveness": "Medium",
+        "last_security_review": "2025-02-20"
+      },
+      "maintenance_health": {
+        "active_contributors": 28,
+        "release_frequency": "High",
+        "issue_response_time": "1.8 days"
+      },
+      "dependency_management": {
+        "vulnerable_dependencies": 4,
+        "dependency_freshness": "Medium",
+        "supply_chain_security": "Low"
+      },
+      "regulatory_compliance": {
+        "documentation_quality": "Low",
+        "data_privacy_features": "Minimal",
+        "audit_readiness": "Low"
+      }
+    }
+  }
+}

src/envs.py

@@ -2,9 +2,14 @@ import os
 
 from huggingface_hub import HfApi
 
+# Run in local mode (no Hugging Face connection required)
+# Set to True when developing locally without HF credentials
+LOCAL_MODE = True
+
 # Info to change for your repository
 # ----------------------------------
-TOKEN = os.environ.get("HF_TOKEN") # A read/write token for your org
+# Get token from environment or use None in local mode
+TOKEN = os.environ.get("HF_TOKEN") if not LOCAL_MODE else None
 
 OWNER = "libvulnwatch" # Change to your org - don't forget to create a results and request dataset, with the correct format!
 # ----------------------------------
@@ -22,4 +27,5 @@ EVAL_RESULTS_PATH = os.path.join(CACHE_PATH, "assessment-results")
 EVAL_REQUESTS_PATH_BACKEND = os.path.join(CACHE_PATH, "assessment-queue-bk")
 EVAL_RESULTS_PATH_BACKEND = os.path.join(CACHE_PATH, "assessment-results-bk")
 
+# Initialize API with token if available
 API = HfApi(token=TOKEN)

src/submission/submit.py

@@ -11,7 +11,8 @@ import requests
 from huggingface_hub import HfApi
 
 from src.display.utils import LibraryType, Language, AssessmentStatus
-from src.envs import API, EVAL_REQUESTS_PATH, QUEUE_REPO, TOKEN
+from src.display.formatting import styled_error, styled_warning, styled_message
+from src.envs import API, EVAL_REQUESTS_PATH, QUEUE_REPO, TOKEN, LOCAL_MODE
 from src.submission.check_validity import is_repository_valid, get_library_info
 
 
@@ -41,12 +42,12 @@ def add_new_eval(
     is_valid, validity_message, library_info = is_repository_valid(library_name, repository_url)
     
     if not is_valid:
-        return f"⚠️ Invalid submission: {validity_message}"
+        return styled_error(f"Invalid submission: {validity_message}")
 
     # Parse library type
     library_type = LibraryType.from_str(library_type_str)
     if library_type == LibraryType.Unknown:
-        return "⚠️ Please select a valid library type."
+        return styled_error("Please select a valid library type.")
 
     # Create a unique identifier for the submission
     uid = uuid.uuid4().hex[:6]
@@ -73,14 +74,22 @@ def add_new_eval(
         "assessment_id": uid
     }
     
-    # Save the request 
+    # Ensure directory exists
     os.makedirs(EVAL_REQUESTS_PATH, exist_ok=True)
-    with open(os.path.join(EVAL_REQUESTS_PATH, request_filename), "w") as f:
+    
+    # Save the request locally
+    request_file_path = os.path.join(EVAL_REQUESTS_PATH, request_filename)
+    with open(request_file_path, "w") as f:
         json.dump(assessment_request, f, indent=2)
     
+    # If in local mode, don't try to upload to HF
+    if LOCAL_MODE:
+        return styled_message(f"Library '{library_name}' (version {library_version}) has been added to the local assessment queue! Assessment ID: {uid}")
+    
+    # Try to upload to HF if not in local mode
     try:
         # Push the file to the HF repo
-        path = Path(os.path.join(EVAL_REQUESTS_PATH, request_filename))
+        path = Path(request_file_path)
         API.upload_file(
             path_or_fileobj=path,
             path_in_repo=request_filename,
@@ -88,7 +97,7 @@ def add_new_eval(
             repo_type="dataset",
         )
         
-        return f"✅ Library '{library_name}' (version {library_version}) has been added to the assessment queue! Assessment ID: {uid}"
+        return styled_message(f"Library '{library_name}' (version {library_version}) has been added to the assessment queue! Assessment ID: {uid}")
     
     except Exception as e:
-        return f"Error uploading assessment request: {str(e)}"
+        return styled_warning(f"Saved locally but failed to upload to Hugging Face: {str(e)}")