zalupa1

README.md

@@ -12,31 +12,211 @@ sdk_version: 5.19.0
 storage: persistent
 ---
 
-# CodeReview Leaderboard
+# 🏆 CodeReview Leaderboard
 
-A leaderboard for evaluating code review models with BLEU, Pass@K metrics, and multi-dimensional subjective scores.
+A comprehensive benchmark and leaderboard for code review generation models, inspired by [circle-guard-bench](https://huggingface.co/spaces/whitecircle-ai/circle-guard-bench).
 
-## Metrics
+## ✨ Features
 
-### Main Metrics (0-1 scale)
+### 🎯 Core Functionality
 
-- **BLEU**: Text similarity score
-- **Pass@1, Pass@5, Pass@10**: LLM-based exact match at different attempts
+- **Multi-dimensional Evaluation**: Track models across BLEU scores, Pass@1/5/10 metrics, and 10 quality dimensions
+- **Advanced Filtering**: Filter results by programming language, comment language, and taxonomy category
+- **Real-time Updates**: Dynamic leaderboard updates with instant filtering
+- **Dark Theme**: Modern, eye-friendly interface with GitHub-inspired dark theme
 
-### Multi-Metrics (0-10 scale)
+### 🔍 Advanced Analytics
 
-- Readability, Relevance, Explanation Clarity
-- Problem Identification, Actionability, Completeness
-- Specificity, Contextual Adequacy, Consistency, Brevity
+- **Language Performance**: Compare model performance across programming languages
+- **Category Analysis**: Analyze performance by review type (bug detection, security, etc.)
+- **Submission History**: Track all submissions with IP-based logging
+- **Statistical Insights**: Comprehensive statistics and trend analysis
 
-## Submission
+### 🛡️ Security & Quality
 
-Submit your model results through the web interface or via API:
+- **IP-based Rate Limiting**: Prevent spam submissions (5 per 24 hours per IP)
+- **Comprehensive Validation**: Multi-layer validation for all submissions
+- **Audit Trail**: Complete submission logging for transparency
+- **Data Integrity**: Automatic data validation and backup systems
+
+### 🌐 Multi-Language Support
+
+- **Programming Languages**: Python, JavaScript, Java, C++, Go, Rust, and more
+- **Comment Languages**: English, Chinese, Spanish, French, German, Japanese, and more
+- **Taxonomy Categories**: Bug Detection, Security, Performance, Style, and more
+
+## 🚀 Quick Start
+
+### Installation
+
+```bash
+pip install -r requirements.txt
+```
+
+### Run Locally
 
 ```bash
-curl -X POST https://kenkaneki--codereviewbench.hf.space/api/submit_model \
-     -H "Content-Type: application/json" \
-     -d '{"data": ["org/model", 0.68, 0.73, 0.82, 0.87, 8, 7, 8, 7, 6, 7, 6, 7, 6, 5]}'
+python app.py
 ```
 
-Results are sorted by **Pass@1** in descending order.
+### Access the Interface
+
+Open your browser to `http://localhost:7860`
+
+## 📊 Usage Guide
+
+### 1. Viewing the Leaderboard
+
+- Navigate to the **🏆 Leaderboard** tab
+- Use the filter dropdowns to narrow results:
+  - **Programming Language**: Filter by specific programming languages
+  - **Comment Language**: Filter by natural language of comments
+  - **Taxonomy Category**: Filter by review category type
+- Click **🔄 Refresh** to update data
+
+### 2. Submitting Models
+
+- Go to the **📝 Submit Model** tab
+- Fill in the submission form:
+  - **Model Name**: Use `organization/model` format
+  - **Languages & Category**: Select appropriate filters
+  - **Performance Scores**: Provide BLEU and Pass@k scores (0.0-1.0)
+  - **Quality Metrics**: Rate across 10 dimensions (0-10)
+- Click **🚀 Submit Model** to add your results
+
+### 3. Analytics & Insights
+
+- Visit the **📈 Analytics** tab to see:
+  - Recent submission history
+  - Language performance comparisons
+  - Category performance analysis
+  - Trends and patterns
+
+### 4. Data Export
+
+- Use the **ℹ️ About** tab to export data in JSON or CSV format
+- Full leaderboard data available for research and analysis
+
+## 🏗️ Architecture
+
+### Directory Structure
+
+```
+├── src/
+│   ├── about.py              # About page content
+│   ├── envs.py               # Environment configuration
+│   ├── display/              # Display utilities
+│   │   ├── css_html_js.py    # Styling and themes
+│   │   ├── formatting.py     # Data formatting
+│   │   └── utils.py          # Display utilities
+│   ├── leaderboard/          # Leaderboard processing
+│   │   └── processor.py      # Data operations
+│   └── submission/           # Submission handling
+│       └── submit.py         # Submission validation
+├── data/                     # Data storage
+│   ├── leaderboard_data.json # Main leaderboard
+│   └── submissions.json      # Submission log
+├── app.py                    # Main application
+└── requirements.txt          # Dependencies
+```
+
+### Key Components
+
+- **LeaderboardProcessor**: Handles all data operations, validation, and persistence
+- **SubmissionHandler**: Manages model submissions with IP tracking and validation
+- **Display Utils**: Provides filtering, formatting, and table generation
+- **Dark Theme**: Custom CSS for modern, accessible interface
+
+## 🎨 Features Inspired by circle-guard-bench
+
+### ✅ Implemented Features
+
+- **Multi-tab Interface**: Organized navigation with dedicated sections
+- **Advanced Filtering**: Real-time filtering by multiple criteria
+- **Dark Theme**: Modern, GitHub-inspired dark interface
+- **IP-based Submissions**: Secure submission tracking
+- **Comprehensive Analytics**: Detailed performance insights
+- **Data Export**: Multiple export formats
+- **Rate Limiting**: Anti-spam protection
+
+### 🔧 Technical Improvements
+
+- **Modular Architecture**: Clean separation of concerns
+- **Type Safety**: Full type annotations throughout
+- **Error Handling**: Comprehensive error handling and logging
+- **Data Validation**: Multi-layer validation with Pydantic
+- **Performance**: Optimized data processing and display
+
+## 📈 Metrics & Evaluation
+
+### Performance Metrics
+
+- **BLEU**: Text similarity score (0.0-1.0)
+- **Pass@1**: Success rate in single attempt (0.0-1.0)
+- **Pass@5**: Success rate in 5 attempts (0.0-1.0)
+- **Pass@10**: Success rate in 10 attempts (0.0-1.0)
+
+### Quality Dimensions
+
+1. **Readability**: How clear and readable are the reviews?
+2. **Relevance**: How relevant to the code changes?
+3. **Explanation Clarity**: How well does it explain issues?
+4. **Problem Identification**: How effectively does it identify problems?
+5. **Actionability**: How actionable are the suggestions?
+6. **Completeness**: How thorough are the reviews?
+7. **Specificity**: How specific are the comments?
+8. **Contextual Adequacy**: How well does it understand context?
+9. **Consistency**: How consistent across different reviews?
+10. **Brevity**: How concise without losing important information?
+
+## 🔒 Security Features
+
+### Rate Limiting
+
+- **5 submissions per IP per 24 hours**
+- **Automatic IP tracking and logging**
+- **Graceful error handling for rate limits**
+
+### Data Validation
+
+- **Model name format validation**
+- **Score range validation (0.0-1.0 for performance, 0-10 for quality)**
+- **Logical consistency checks (Pass@1 ≤ Pass@5 ≤ Pass@10)**
+- **Required field validation**
+
+### Audit Trail
+
+- **Complete submission logging**
+- **IP address tracking (partially masked for privacy)**
+- **Timestamp recording**
+- **Data integrity checks**
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests if applicable
+5. Submit a pull request
+
+## 📄 License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## 🙏 Acknowledgments
+
+- Inspired by [circle-guard-bench](https://huggingface.co/spaces/whitecircle-ai/circle-guard-bench)
+- Built with [Gradio](https://gradio.app/) for the web interface
+- Thanks to the open-source community for tools and inspiration
+
+## 📞 Support
+
+For questions, issues, or contributions:
+
+- Open an issue on GitHub
+- Check the documentation
+- Contact the maintainers
+
+---
+
+**Built with ❤️ for the code review research community**

app.py

@@ -1,275 +1,365 @@
-import json
-from pathlib import Path
-from typing import List, Dict
-import os
+"""
+CodeReview Leaderboard - Inspired by circle-guard-bench
+A comprehensive leaderboard for code review generation models
+"""
 
 import gradio as gr
-from pydantic import BaseModel, Field, field_validator
-
-# --------------- Configuration ---------------
-LEADERBOARD_PATH = Path("leaderboard_data.json")
-
-# Initialize with default data
-DEFAULT_DATA = [{
-    "model_name": "example/model",
-    "bleu": 0.5,
-    "llm_pass_1": 0.5,
-    "llm_pass_5": 0.5,
-    "llm_pass_10": 0.5,
-    "metrics": {
-        "readability": 5, "relevance": 5, "explanation_clarity": 5,
-        "problem_identification": 5, "actionability": 5, "completeness": 5,
-        "specificity": 5, "contextual_adequacy": 5, "consistency": 5, "brevity": 5
+from typing import List, Dict, Any
+from datetime import datetime, timezone
+
+# Import our modules
+from src.envs import (
+    PROGRAMMING_LANGUAGES, COMMENT_LANGUAGES, TAXONOMY_CATEGORIES,
+    MAIN_HEADERS, QUALITY_HEADERS
+)
+from src.about import TITLE, INTRODUCTION_TEXT
+from src.display.css_html_js import DARK_THEME_CSS, CUSTOM_JS, HEADER_HTML, FOOTER_HTML
+from src.display.utils import (
+    get_main_leaderboard_data, get_quality_metrics_data, 
+    get_submission_history_data, get_statistics_summary
+)
+from src.leaderboard.processor import LeaderboardProcessor
+from src.submission.submit import SubmissionHandler
+
+# Initialize processors
+processor = LeaderboardProcessor()
+submission_handler = SubmissionHandler()
+
+# Global state
+current_filters = {
+    "programming_language": "All",
+    "comment_language": "All",
+    "taxonomy_category": "All"
+}
+
+def update_leaderboard_tables(
+    programming_language: str = "All",
+    comment_language: str = "All",
+    taxonomy_category: str = "All"
+):
+    """Update leaderboard tables with filters"""
+    global current_filters
+    current_filters = {
+        "programming_language": programming_language,
+        "comment_language": comment_language,
+        "taxonomy_category": taxonomy_category
     }
-}]
-
-# --------------- Data models ---------------
-class Metrics(BaseModel):
-    readability: int
-    relevance: int
-    explanation_clarity: int = Field(alias="explanation_clarity")
-    problem_identification: int
-    actionability: int
-    completeness: int
-    specificity: int
-    contextual_adequacy: int
-    consistency: int
-    brevity: int
-
-    @field_validator("readability", "relevance", "explanation_clarity", "problem_identification", "actionability", "completeness", "specificity", "contextual_adequacy", "consistency", "brevity")
-    def metric_range(cls, v: int):
-        if not 0 <= v <= 10:
-            raise ValueError("Multi-metrics should be between 0 and 10")
-        return v
-
-
-class LeaderboardEntry(BaseModel):
-    model_name: str
-    bleu: float
-    llm_pass_1: float
-    llm_pass_5: float
-    llm_pass_10: float
-    metrics: Metrics
-
-    @field_validator("bleu", "llm_pass_1", "llm_pass_5", "llm_pass_10")
-    def score_range(cls, v: float):
-        if not 0.0 <= v <= 1.0:
-            raise ValueError("Scores should be between 0 and 1")
-        return v
-
-
-# --------------- Persistence helpers ---------------
-
-def _load_leaderboard() -> List[Dict]:
-    """Load leaderboard data with persistent storage support."""
-    if not LEADERBOARD_PATH.exists():
-        # Create default example data
-        _save_leaderboard(DEFAULT_DATA)
-        return DEFAULT_DATA
     
-    try:
-        with LEADERBOARD_PATH.open("r", encoding="utf-8") as f:
-            data = json.load(f)
-            return data.get("leaderboard", [])
-    except Exception as e:
-        print(f"Error loading leaderboard: {e}")
-        return []
-
-
-def _save_leaderboard(data: List[Dict]):
-    """Save leaderboard data to persistent storage."""
-    try:
-        to_store = {"leaderboard": data}
-        with LEADERBOARD_PATH.open("w", encoding="utf-8") as f:
-            json.dump(to_store, f, indent=2)
-    except Exception as e:
-        print(f"Error saving leaderboard: {e}")
-
-
-# --------------- Table data functions ---------------
-
-def _table_data(data: List[Dict] = None) -> List[List]:
-    """Get main metrics table data."""
-    if data is None:
-        data = _load_leaderboard()
-    if not data:
-        return []
-    data.sort(key=lambda x: x["llm_pass_1"], reverse=True)
+    # Load current data
+    data = processor.load_leaderboard_data()
     
-    table_rows = []
-    for entry in data:
-        row = [
-            entry["model_name"],
-            entry["bleu"],
-            entry["llm_pass_1"],
-            entry["llm_pass_5"],
-            entry["llm_pass_10"],
-        ]
-        table_rows.append(row)
-    return table_rows
-
-
-def _multimetric_table_data(data: List[Dict] = None) -> List[List]:
-    """Get multi-metric table data."""
-    if data is None:
-        data = _load_leaderboard()
-    if not data:
-        return []
-    data.sort(key=lambda x: x["llm_pass_1"], reverse=True)
+    # Get filtered tables
+    main_table = get_main_leaderboard_data(
+        data, programming_language, comment_language, taxonomy_category
+    )
     
-    table_rows = []
-    for entry in data:
-        row = [
-            entry["model_name"],
-            entry["metrics"]["readability"],
-            entry["metrics"]["relevance"],
-            entry["metrics"]["explanation_clarity"],
-            entry["metrics"]["problem_identification"],
-            entry["metrics"]["actionability"],
-            entry["metrics"]["completeness"],
-            entry["metrics"]["specificity"],
-            entry["metrics"]["contextual_adequacy"],
-            entry["metrics"]["consistency"],
-            entry["metrics"]["brevity"],
-        ]
-        table_rows.append(row)
-    return table_rows
-
-
-# --------------- Gradio callbacks ---------------
+    quality_table = get_quality_metrics_data(
+        data, programming_language, comment_language, taxonomy_category
+    )
+    
+    # Get statistics
+    stats = get_statistics_summary(data)
+    
+    # Format statistics display
+    stats_text = f"""
+    ## 📊 Current Statistics
+    - **Total Models**: {stats['total_models']}
+    - **Total Submissions**: {stats['total_submissions']}
+    - **Average Pass@1**: {stats['avg_pass_1']:.3f}
+    - **Best Model**: {stats['best_model']}
+    - **Languages Covered**: {stats['languages_covered']}
+    - **Categories Covered**: {stats['categories_covered']}
+    """
+    
+    return main_table, quality_table, stats_text
+
+def refresh_data():
+    """Refresh all data from storage"""
+    return update_leaderboard_tables(
+        current_filters["programming_language"],
+        current_filters["comment_language"],
+        current_filters["taxonomy_category"]
+    )
 
-def submit_model(
-    current_data: List[Dict],
-    model_name: str,
-    bleu: float,
-    llm_pass_1: float,
-    llm_pass_5: float,
-    llm_pass_10: float,
-    readability: int,
-    relevance: int,
-    explanation_clarity: int,
-    problem_identification: int,
-    actionability: int,
-    completeness: int,
-    specificity: int,
-    contextual_adequacy: int,
-    consistency: int,
-    brevity: int,
+def handle_submission(
+    request: gr.Request,
+    *args
 ):
-    """Validate and append a new model entry to the leaderboard."""
-    try:
-        entry = LeaderboardEntry(
-            model_name=model_name.strip(),
-            bleu=bleu,
-            llm_pass_1=llm_pass_1,
-            llm_pass_5=llm_pass_5,
-            llm_pass_10=llm_pass_10,
-            metrics={
-                "readability": readability,
-                "relevance": relevance,
-                "explanation_clarity": explanation_clarity,
-                "problem_identification": problem_identification,
-                "actionability": actionability,
-                "completeness": completeness,
-                "specificity": specificity,
-                "contextual_adequacy": contextual_adequacy,
-                "consistency": consistency,
-                "brevity": brevity,
-            },
+    """Handle model submission"""
+    # Get current data
+    current_data = processor.load_leaderboard_data()
+    
+    # Call submission handler
+    result = submission_handler.submit_model(request, current_data, *args)
+    
+    # If submission was successful, refresh tables
+    if result[0] != current_data:  # Data was updated
+        main_table, quality_table, stats_text = update_leaderboard_tables(
+            current_filters["programming_language"],
+            current_filters["comment_language"],
+            current_filters["taxonomy_category"]
         )
-    except Exception as e:
-        return current_data, _table_data(current_data), _multimetric_table_data(current_data), f"❌ Submission failed: {e}"
-
-    # Use current data from state
-    data = current_data.copy() if current_data else []
-    # Replace existing model entry if any
-    data = [d for d in data if d["model_name"] != entry.model_name]
-    data.append(entry.dict())
-    _save_leaderboard(data)
-
-    return data, _table_data(data), _multimetric_table_data(data), "✅ Submission recorded!"
-
-
-# --------------- Interface ---------------
-with gr.Blocks(title="CodeReview Leaderboard") as demo:
-    gr.Markdown("""# 🏆 CodeReview Leaderboard\nSubmit your model results below. Leaderboard is sorted by **Pass@1**. """)
-
-    # Initialize table data
-    initial_leaderboard_data = _load_leaderboard()
-    initial_data = _table_data(initial_leaderboard_data)
-    initial_multimetric_data = _multimetric_table_data(initial_leaderboard_data)
+        return result[0], main_table, quality_table, result[3], stats_text
+    else:
+        return result[0], result[1], result[2], result[3], None
+
+# Create the Gradio interface
+with gr.Blocks(
+    theme=gr.themes.Base(),
+    css=DARK_THEME_CSS,
+    js=CUSTOM_JS,
+    title=TITLE,
+    head="<meta name='viewport' content='width=device-width, initial-scale=1'>"
+) as demo:
+    
+    # Header
+    gr.HTML(HEADER_HTML)
     
     # State to store leaderboard data
-    leaderboard_state = gr.State(value=initial_leaderboard_data)
+    leaderboard_state = gr.State(value=processor.load_leaderboard_data())
     
-    leaderboard_df = gr.Dataframe(
-        headers=["Model", "BLEU", "Pass@1", "Pass@5", "Pass@10"],
-        value=initial_data,
-        label="Main Metrics Leaderboard",
-        interactive=False,
-    )
-
-    multimetric_df = gr.Dataframe(
-        headers=["Model", "Readability", "Relevance", "Explanation Clarity", "Problem Identification", "Actionability", "Completeness", "Specificity", "Contextual Adequacy", "Consistency", "Brevity"],
-        value=initial_multimetric_data,
-        label="Multi-Metric Scores",
-        interactive=False,
+    # Main content tabs
+    with gr.Tabs():
+        
+        # Leaderboard Tab
+        with gr.Tab("🏆 Leaderboard"):
+            
+            # Filters
+            with gr.Row():
+                prog_lang_filter = gr.Dropdown(
+                    choices=PROGRAMMING_LANGUAGES,
+                    value="All",
+                    label="🔍 Programming Language",
+                    info="Filter by programming language"
+                )
+                comment_lang_filter = gr.Dropdown(
+                    choices=COMMENT_LANGUAGES,
+                    value="All",
+                    label="🌍 Comment Language",
+                    info="Filter by comment language"
+                )
+                taxonomy_filter = gr.Dropdown(
+                    choices=TAXONOMY_CATEGORIES,
+                    value="All",
+                    label="🏷️ Taxonomy Category",
+                    info="Filter by review category"
+                )
+                refresh_btn = gr.Button("🔄 Refresh", variant="secondary")
+            
+            # Statistics
+            stats_display = gr.Markdown("")
+            
+            # Main leaderboard table
+            with gr.Row():
+                main_leaderboard = gr.Dataframe(
+                    headers=MAIN_HEADERS,
+                    label="🏅 Main Leaderboard",
+                    interactive=False,
+                    wrap=True,
+                    max_height=600
+                )
+            
+            # Quality metrics table
+            with gr.Row():
+                quality_metrics = gr.Dataframe(
+                    headers=QUALITY_HEADERS,
+                    label="📊 Quality Metrics",
+                    interactive=False,
+                    wrap=True,
+                    max_height=600
+                )
+        
+        # Submission Tab
+        with gr.Tab("📝 Submit Model"):
+            
+            # Create submission form
+            form_components = submission_handler.get_submission_form_components()
+            
+            # Connect submission handler
+            form_components["submit_btn"].click(
+                fn=handle_submission,
+                inputs=[
+                    leaderboard_state,
+                    form_components["model_name"],
+                    form_components["programming_language"],
+                    form_components["comment_language"],
+                    form_components["taxonomy_category"],
+                    form_components["bleu"],
+                    form_components["pass1"],
+                    form_components["pass5"],
+                    form_components["pass10"],
+                    form_components["readability"],
+                    form_components["relevance"],
+                    form_components["explanation_clarity"],
+                    form_components["problem_identification"],
+                    form_components["actionability"],
+                    form_components["completeness"],
+                    form_components["specificity"],
+                    form_components["contextual_adequacy"],
+                    form_components["consistency"],
+                    form_components["brevity"],
+                ],
+                outputs=[
+                    leaderboard_state,
+                    main_leaderboard,
+                    quality_metrics,
+                    form_components["status_msg"],
+                    stats_display
+                ]
+            )
+        
+        # Analytics Tab
+        with gr.Tab("📈 Analytics"):
+            
+            with gr.Row():
+                analytics_prog_lang = gr.Dropdown(
+                    choices=PROGRAMMING_LANGUAGES,
+                    value="All",
+                    label="Programming Language"
+                )
+                analytics_comment_lang = gr.Dropdown(
+                    choices=COMMENT_LANGUAGES,
+                    value="All",
+                    label="Comment Language"
+                )
+                analytics_taxonomy = gr.Dropdown(
+                    choices=TAXONOMY_CATEGORIES,
+                    value="All",
+                    label="Taxonomy Category"
+                )
+            
+            # Submission history
+            submission_history = gr.Dataframe(
+                headers=["Model", "Programming Language", "Comment Language", "Taxonomy", "Pass@1", "Date", "IP"],
+                label="📋 Recent Submissions",
+                interactive=False,
+                max_height=400
+            )
+            
+            # Language performance analysis
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### 🗣️ Language Performance Analysis")
+                    language_analysis = gr.Dataframe(
+                        headers=["Language", "Avg Pass@1", "Model Count", "Best Model"],
+                        label="Programming Language Performance",
+                        interactive=False
+                    )
+                
+                with gr.Column():
+                    gr.Markdown("### 🏷️ Category Performance Analysis")
+                    category_analysis = gr.Dataframe(
+                        headers=["Category", "Avg Pass@1", "Model Count", "Best Model"],
+                        label="Taxonomy Category Performance",
+                        interactive=False
+                    )
+        
+        # About Tab
+        with gr.Tab("ℹ️ About"):
+            gr.Markdown(INTRODUCTION_TEXT)
+            
+            # Export functionality
+            with gr.Row():
+                export_format = gr.Dropdown(
+                    choices=["JSON", "CSV"],
+                    value="JSON",
+                    label="Export Format"
+                )
+                export_btn = gr.Button("📥 Export Data")
+            
+            export_output = gr.Textbox(
+                label="Export Output",
+                lines=10,
+                max_lines=20,
+                show_copy_button=True
+            )
+    
+    # Footer
+    gr.HTML(FOOTER_HTML)
+    
+    # Initialize with data
+    initial_main, initial_quality, initial_stats = update_leaderboard_tables()
+    
+    # Update tables when filters change
+    filter_inputs = [prog_lang_filter, comment_lang_filter, taxonomy_filter]
+    filter_outputs = [main_leaderboard, quality_metrics, stats_display]
+    
+    for filter_input in filter_inputs:
+        filter_input.change(
+            fn=update_leaderboard_tables,
+            inputs=filter_inputs,
+            outputs=filter_outputs
+        )
+    
+    # Refresh button
+    refresh_btn.click(
+        fn=refresh_data,
+        outputs=filter_outputs
     )
-
-    gr.Markdown("## 🔄 Submit new model results")
-
-    with gr.Accordion("Submission form", open=False):
-        with gr.Row():
-            model_name_inp = gr.Text(label="Model name (org/model)", value="")
-            bleu_inp = gr.Number(label="BLEU", value=0.0, minimum=0.0, maximum=1.0)
-            pass1_inp = gr.Number(label="Pass@1", value=0.0, minimum=0.0, maximum=1.0)
-            pass5_inp = gr.Number(label="Pass@5", value=0.0, minimum=0.0, maximum=1.0)
-            pass10_inp = gr.Number(label="Pass@10", value=0.0, minimum=0.0, maximum=1.0)
-
-        gr.Markdown("### Multi-metric subjective scores (0 – 10)")
-        with gr.Row():
-            readability_inp = gr.Slider(minimum=0, maximum=10, value=5, step=1, label="Readability")
-            relevance_inp = gr.Slider(minimum=0, maximum=10, value=5, step=1, label="Relevance")
-            explanation_inp = gr.Slider(minimum=0, maximum=10, value=5, step=1, label="Explanation Clarity")
-            problem_inp = gr.Slider(minimum=0, maximum=10, value=5, step=1, label="Problem Identification")
-            actionability_inp = gr.Slider(minimum=0, maximum=10, value=5, step=1, label="Actionability")
-            completeness_inp = gr.Slider(minimum=0, maximum=10, value=5, step=1, label="Completeness")
-            specificity_inp = gr.Slider(minimum=0, maximum=10, value=5, step=1, label="Specificity")
-            contextual_inp = gr.Slider(minimum=0, maximum=10, value=5, step=1, label="Contextual Adequacy")
-            consistency_inp = gr.Slider(minimum=0, maximum=10, value=5, step=1, label="Consistency")
-            brevity_inp = gr.Slider(minimum=0, maximum=10, value=5, step=1, label="Brevity")
-
-        submit_btn = gr.Button("Submit")
-        status_markdown = gr.Markdown("")
-
-        submit_btn.click(
-            fn=submit_model,
-            inputs=[
-                leaderboard_state,
-                model_name_inp,
-                bleu_inp,
-                pass1_inp,
-                pass5_inp,
-                pass10_inp,
-                readability_inp,
-                relevance_inp,
-                explanation_inp,
-                problem_inp,
-                actionability_inp,
-                completeness_inp,
-                specificity_inp,
-                contextual_inp,
-                consistency_inp,
-                brevity_inp,
-            ],
-            outputs=[leaderboard_state, leaderboard_df, multimetric_df, status_markdown],
-            api_name="submit_model",
+    
+    # Analytics updates
+    analytics_inputs = [analytics_prog_lang, analytics_comment_lang, analytics_taxonomy]
+    
+    def update_analytics(prog_lang, comment_lang, taxonomy):
+        """Update analytics tables"""
+        data = processor.load_leaderboard_data()
+        
+        # Get submission history
+        history = get_submission_history_data(data, prog_lang, comment_lang, taxonomy)
+        
+        # Get language performance
+        lang_perf = []
+        for lang in PROGRAMMING_LANGUAGES[1:]:
+            lang_data = [d for d in data if d.get("programming_language") == lang]
+            if lang_data:
+                avg_score = sum(d.get("llm_pass_1", 0) for d in lang_data) / len(lang_data)
+                best_model = max(lang_data, key=lambda x: x.get("llm_pass_1", 0)).get("model_name", "")
+                lang_perf.append([lang, f"{avg_score:.3f}", len(lang_data), best_model])
+        
+        # Get category performance
+        cat_perf = []
+        for cat in TAXONOMY_CATEGORIES[1:]:
+            cat_data = [d for d in data if d.get("taxonomy_category") == cat]
+            if cat_data:
+                avg_score = sum(d.get("llm_pass_1", 0) for d in cat_data) / len(cat_data)
+                best_model = max(cat_data, key=lambda x: x.get("llm_pass_1", 0)).get("model_name", "")
+                cat_perf.append([cat, f"{avg_score:.3f}", len(cat_data), best_model])
+        
+        return history, lang_perf, cat_perf
+    
+    for analytics_input in analytics_inputs:
+        analytics_input.change(
+            fn=update_analytics,
+            inputs=analytics_inputs,
+            outputs=[submission_history, language_analysis, category_analysis]
         )
+    
+    # Export functionality
+    def export_data(format_type):
+        """Export leaderboard data"""
+        return processor.export_data(format_type.lower())
+    
+    export_btn.click(
+        fn=export_data,
+        inputs=[export_format],
+        outputs=[export_output]
+    )
+    
+    # Set initial values
+    demo.load(
+        fn=lambda: (initial_main, initial_quality, initial_stats),
+        outputs=[main_leaderboard, quality_metrics, stats_display]
+    )
 
-# ----------------- Launch -----------------
-
+# Launch configuration
 if __name__ == "__main__":
-    demo.queue().launch()
+    demo.queue(max_size=20).launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True,
+        debug=True
+    )
 
-# For HF Spaces runtime (gradio SDK) expose `demo`
+# For deployment (HuggingFace Spaces, etc.)
 app = demo

data/.gitkeep

@@ -0,0 +1 @@
+# Keep this directory in git 

data/leaderboard_data.json

@@ -0,0 +1,30 @@
+{
+  "leaderboard": [
+    {
+      "model_name": "example/model",
+      "programming_language": "Python",
+      "comment_language": "English",
+      "taxonomy_category": "Bug Detection",
+      "bleu": 0.5,
+      "llm_pass_1": 0.5,
+      "llm_pass_5": 0.5,
+      "llm_pass_10": 0.5,
+      "metrics": {
+        "readability": 5,
+        "relevance": 5,
+        "explanation_clarity": 5,
+        "problem_identification": 5,
+        "actionability": 5,
+        "completeness": 5,
+        "specificity": 5,
+        "contextual_adequacy": 5,
+        "consistency": 5,
+        "brevity": 5
+      },
+      "submission_ip": "127.0.0.1",
+      "submission_date": "2024-01-01T00:00:00Z"
+    }
+  ],
+  "last_updated": "2025-07-03T13:10:47.434623+00:00",
+  "total_entries": 1
+}

data/submissions.json

@@ -0,0 +1,5 @@
+{
+  "submissions": [],
+  "last_updated": "2025-07-03T13:10:47.435548+00:00",
+  "total_submissions": 0
+}

requirements.txt

@@ -1,18 +1,19 @@
 APScheduler
 black
 datasets
-gradio
+gradio>=4.0.0
 gradio[oauth]
 gradio_leaderboard==0.0.13
 gradio_client
 huggingface-hub>=0.18.0
 matplotlib
 numpy
-pandas
+pandas>=1.3.0
 python-dateutil
 tqdm
 transformers
 tokenizers>=0.15.0
 sentencepiece
 fastapi
-uvicorn
+uvicorn
+pydantic>=2.0.0

src/__init__.py

@@ -0,0 +1 @@
+# CodeReview Leaderboard - Source Module 

src/about.py

@@ -0,0 +1,48 @@
+"""
+About page content for CodeReview Leaderboard
+"""
+
+TITLE = "🏆 CodeReview Leaderboard"
+
+INTRODUCTION_TEXT = """
+# CodeReview Leaderboard
+
+A comprehensive benchmark for evaluating code review generation models across multiple programming languages and comment types.
+
+## Overview
+
+This leaderboard tracks the performance of various models on code review tasks, providing insights into:
+- **Programming Language Performance**: How well models perform across different programming languages
+- **Comment Language Support**: Effectiveness in generating reviews in different natural languages  
+- **Taxonomy Categories**: Performance across different types of code review feedback
+
+## Metrics
+
+- **BLEU**: Measures similarity between generated and reference reviews
+- **Pass@1/5/10**: Percentage of reviews that pass quality checks in 1, 5, or 10 attempts
+- **Multi-dimensional Quality Scores**: Detailed evaluation across 10 quality dimensions
+
+## Features
+
+✨ **Filter by Programming Language**: View results for specific programming languages (Python, JavaScript, Java, etc.)
+✨ **Comment Language Support**: Filter by the natural language of code comments
+✨ **Taxonomy Categories**: Browse results by review type (bug detection, style, performance, etc.)
+✨ **IP-based Submissions**: Secure submission system with IP tracking
+✨ **Dark Theme**: Modern, eye-friendly interface
+"""
+
+SUBMISSION_GUIDELINES = """
+## Submission Guidelines
+
+1. **Model Requirements**: Submit results for at least 100 test cases
+2. **Format**: Provide scores in the specified format ranges
+3. **Reproducibility**: Include model details and evaluation setup
+4. **Quality Metrics**: Rate your model across all 10 quality dimensions
+5. **Metadata**: Specify programming language, comment language, and taxonomy focus
+"""
+
+CONTACT_INFO = """
+## Contact & Support
+
+For questions, issues, or contributions, please reach out through our repository or contact the maintainers.
+""" 

src/display/__init__.py

@@ -0,0 +1 @@
+# Display utilities module 

src/display/css_html_js.py

@@ -0,0 +1,305 @@
+"""
+Custom CSS, HTML, and JavaScript for the CodeReview Leaderboard
+"""
+
+# Dark theme CSS
+DARK_THEME_CSS = """
+/* Dark Theme Styling */
+:root {
+    --bg-primary: #0d1117;
+    --bg-secondary: #161b22;
+    --bg-tertiary: #21262d;
+    --text-primary: #e6edf3;
+    --text-secondary: #7d8590;
+    --border-color: #30363d;
+    --accent-color: #238636;
+    --accent-hover: #2ea043;
+    --danger-color: #da3633;
+    --warning-color: #d29922;
+    --info-color: #1f6feb;
+}
+
+/* Global dark theme */
+.gradio-container {
+    background: var(--bg-primary) !important;
+    color: var(--text-primary) !important;
+}
+
+/* Headers and text */
+.gradio-container h1, .gradio-container h2, .gradio-container h3 {
+    color: var(--text-primary) !important;
+}
+
+.gradio-container p, .gradio-container span {
+    color: var(--text-secondary) !important;
+}
+
+/* Tabs */
+.gradio-container .tab-nav {
+    background: var(--bg-secondary) !important;
+    border-bottom: 1px solid var(--border-color) !important;
+}
+
+.gradio-container .tab-nav button {
+    background: transparent !important;
+    color: var(--text-secondary) !important;
+    border: none !important;
+    padding: 12px 24px !important;
+    transition: all 0.2s ease !important;
+}
+
+.gradio-container .tab-nav button:hover {
+    color: var(--text-primary) !important;
+    background: var(--bg-tertiary) !important;
+}
+
+.gradio-container .tab-nav button.selected {
+    color: var(--text-primary) !important;
+    background: var(--bg-tertiary) !important;
+    border-bottom: 2px solid var(--accent-color) !important;
+}
+
+/* Tables */
+.gradio-container .dataframe {
+    background: var(--bg-secondary) !important;
+    border: 1px solid var(--border-color) !important;
+    border-radius: 8px !important;
+    overflow: hidden !important;
+}
+
+.gradio-container .dataframe table {
+    background: var(--bg-secondary) !important;
+}
+
+.gradio-container .dataframe th {
+    background: var(--bg-tertiary) !important;
+    color: var(--text-primary) !important;
+    border-bottom: 2px solid var(--border-color) !important;
+    padding: 12px !important;
+    font-weight: 600 !important;
+}
+
+.gradio-container .dataframe td {
+    background: var(--bg-secondary) !important;
+    color: var(--text-primary) !important;
+    border-bottom: 1px solid var(--border-color) !important;
+    padding: 10px 12px !important;
+}
+
+.gradio-container .dataframe tr:hover td {
+    background: var(--bg-tertiary) !important;
+}
+
+/* Form inputs */
+.gradio-container input, .gradio-container select, .gradio-container textarea {
+    background: var(--bg-tertiary) !important;
+    color: var(--text-primary) !important;
+    border: 1px solid var(--border-color) !important;
+    border-radius: 6px !important;
+    padding: 8px 12px !important;
+}
+
+.gradio-container input:focus, .gradio-container select:focus, .gradio-container textarea:focus {
+    border-color: var(--accent-color) !important;
+    box-shadow: 0 0 0 2px rgba(35, 134, 54, 0.2) !important;
+}
+
+/* Buttons */
+.gradio-container button {
+    background: var(--accent-color) !important;
+    color: white !important;
+    border: none !important;
+    border-radius: 6px !important;
+    padding: 8px 16px !important;
+    font-weight: 500 !important;
+    transition: all 0.2s ease !important;
+}
+
+.gradio-container button:hover {
+    background: var(--accent-hover) !important;
+    transform: translateY(-1px) !important;
+}
+
+.gradio-container button:active {
+    transform: translateY(0) !important;
+}
+
+/* Dropdowns */
+.gradio-container .dropdown {
+    background: var(--bg-tertiary) !important;
+    border: 1px solid var(--border-color) !important;
+    border-radius: 6px !important;
+}
+
+.gradio-container .dropdown-menu {
+    background: var(--bg-secondary) !important;
+    border: 1px solid var(--border-color) !important;
+    border-radius: 6px !important;
+    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.3) !important;
+}
+
+.gradio-container .dropdown-menu .dropdown-item {
+    color: var(--text-primary) !important;
+    padding: 8px 12px !important;
+}
+
+.gradio-container .dropdown-menu .dropdown-item:hover {
+    background: var(--bg-tertiary) !important;
+}
+
+/* Sliders */
+.gradio-container .slider {
+    background: var(--bg-tertiary) !important;
+}
+
+.gradio-container .slider input[type="range"] {
+    background: var(--bg-tertiary) !important;
+}
+
+.gradio-container .slider input[type="range"]::-webkit-slider-thumb {
+    background: var(--accent-color) !important;
+    border: 2px solid var(--bg-secondary) !important;
+    border-radius: 50% !important;
+    width: 18px !important;
+    height: 18px !important;
+}
+
+.gradio-container .slider input[type="range"]::-webkit-slider-track {
+    background: var(--border-color) !important;
+    border-radius: 4px !important;
+    height: 6px !important;
+}
+
+/* Accordions */
+.gradio-container .accordion {
+    background: var(--bg-secondary) !important;
+    border: 1px solid var(--border-color) !important;
+    border-radius: 8px !important;
+    margin: 16px 0 !important;
+}
+
+.gradio-container .accordion-header {
+    background: var(--bg-tertiary) !important;
+    color: var(--text-primary) !important;
+    padding: 16px !important;
+    border-bottom: 1px solid var(--border-color) !important;
+    cursor: pointer !important;
+    font-weight: 500 !important;
+}
+
+.gradio-container .accordion-header:hover {
+    background: var(--bg-primary) !important;
+}
+
+/* Status messages */
+.gradio-container .success {
+    background: rgba(35, 134, 54, 0.1) !important;
+    color: var(--accent-color) !important;
+    border: 1px solid var(--accent-color) !important;
+    border-radius: 6px !important;
+    padding: 12px 16px !important;
+    margin: 8px 0 !important;
+}
+
+.gradio-container .error {
+    background: rgba(218, 54, 51, 0.1) !important;
+    color: var(--danger-color) !important;
+    border: 1px solid var(--danger-color) !important;
+    border-radius: 6px !important;
+    padding: 12px 16px !important;
+    margin: 8px 0 !important;
+}
+
+/* Responsive design */
+@media (max-width: 768px) {
+    .gradio-container {
+        padding: 16px !important;
+    }
+    
+    .gradio-container .tab-nav button {
+        padding: 8px 16px !important;
+        font-size: 14px !important;
+    }
+    
+    .gradio-container .dataframe {
+        font-size: 14px !important;
+    }
+}
+"""
+
+# Custom JavaScript for enhanced functionality
+CUSTOM_JS = """
+// Enhanced table sorting and filtering
+function enhanceTable() {
+    const tables = document.querySelectorAll('.dataframe table');
+    tables.forEach(table => {
+        // Add sorting functionality
+        const headers = table.querySelectorAll('th');
+        headers.forEach((header, index) => {
+            header.style.cursor = 'pointer';
+            header.addEventListener('click', () => sortTable(table, index));
+        });
+    });
+}
+
+function sortTable(table, columnIndex) {
+    const tbody = table.querySelector('tbody');
+    const rows = Array.from(tbody.querySelectorAll('tr'));
+    
+    rows.sort((a, b) => {
+        const aText = a.cells[columnIndex].textContent.trim();
+        const bText = b.cells[columnIndex].textContent.trim();
+        
+        // Try to parse as numbers first
+        const aNum = parseFloat(aText);
+        const bNum = parseFloat(bText);
+        
+        if (!isNaN(aNum) && !isNaN(bNum)) {
+            return bNum - aNum; // Descending for numbers
+        }
+        
+        return aText.localeCompare(bText); // Ascending for text
+    });
+    
+    rows.forEach(row => tbody.appendChild(row));
+}
+
+// Auto-refresh functionality
+function autoRefresh() {
+    setInterval(() => {
+        const refreshBtn = document.querySelector('button[aria-label="Refresh"]');
+        if (refreshBtn) {
+            refreshBtn.click();
+        }
+    }, 30000); // Refresh every 30 seconds
+}
+
+// Initialize enhancements
+document.addEventListener('DOMContentLoaded', function() {
+    enhanceTable();
+    autoRefresh();
+});
+"""
+
+# HTML components
+HEADER_HTML = """
+<div style="text-align: center; padding: 20px; background: var(--bg-secondary); border-radius: 12px; margin-bottom: 20px;">
+    <h1 style="color: var(--text-primary); margin: 0; font-size: 2.5em; font-weight: 700;">
+        🏆 CodeReview Leaderboard
+    </h1>
+    <p style="color: var(--text-secondary); margin: 10px 0 0 0; font-size: 1.2em;">
+        Benchmarking code review generation models across languages and categories
+    </p>
+</div>
+"""
+
+FOOTER_HTML = """
+<div style="text-align: center; padding: 20px; background: var(--bg-secondary); border-radius: 12px; margin-top: 20px;">
+    <p style="color: var(--text-secondary); margin: 0; font-size: 0.9em;">
+        Built with ❤️ for the code review community | 
+        <a href="https://github.com/your-repo" style="color: var(--accent-color); text-decoration: none;">
+            GitHub
+        </a>
+    </p>
+</div>
+""" 

src/display/formatting.py

@@ -0,0 +1,182 @@
+"""
+Formatting utilities for display components
+"""
+
+import re
+from typing import List, Dict, Any, Optional
+from datetime import datetime, timezone
+
+def format_score(score: float, precision: int = 3) -> str:
+    """Format a score with specified precision"""
+    if isinstance(score, (int, float)):
+        return f"{score:.{precision}f}"
+    return str(score)
+
+def format_percentage(score: float, precision: int = 1) -> str:
+    """Format a score as percentage"""
+    if isinstance(score, (int, float)):
+        return f"{score * 100:.{precision}f}%"
+    return str(score)
+
+def format_model_name(name: str) -> str:
+    """Format model name for display"""
+    # Remove common prefixes and make more readable
+    name = name.strip()
+    if "/" in name:
+        org, model = name.split("/", 1)
+        return f"<span style='color: var(--text-secondary); font-size: 0.9em;'>{org}/</span><strong>{model}</strong>"
+    return f"<strong>{name}</strong>"
+
+def format_timestamp(timestamp: str) -> str:
+    """Format timestamp for display"""
+    try:
+        dt = datetime.fromisoformat(timestamp.replace("Z", "+00:00"))
+        return dt.strftime("%Y-%m-%d %H:%M UTC")
+    except:
+        return timestamp
+
+def format_ip_address(ip: str) -> str:
+    """Format IP address for display (partial masking)"""
+    if not ip:
+        return "Unknown"
+    
+    # Mask part of IP for privacy
+    parts = ip.split(".")
+    if len(parts) == 4:
+        return f"{parts[0]}.{parts[1]}.{parts[2]}.xxx"
+    return "xxx.xxx.xxx.xxx"
+
+def format_metric_score(score: int, metric_name: str) -> str:
+    """Format metric score with color coding"""
+    if not isinstance(score, (int, float)):
+        return str(score)
+    
+    # Color coding based on score
+    if score >= 8:
+        color = "#28a745"  # Green
+    elif score >= 6:
+        color = "#ffc107"  # Yellow
+    elif score >= 4:
+        color = "#fd7e14"  # Orange
+    else:
+        color = "#dc3545"  # Red
+    
+    return f"<span style='color: {color}; font-weight: 600;'>{score}</span>"
+
+def format_language_badge(language: str) -> str:
+    """Format programming language as a badge"""
+    if not language or language == "All":
+        return language
+    
+    # Language-specific colors
+    colors = {
+        "Python": "#3776ab",
+        "JavaScript": "#f7df1e",
+        "Java": "#ed8b00",
+        "C++": "#00599c",
+        "C#": "#239120",
+        "Go": "#00add8",
+        "Rust": "#ce422b",
+        "TypeScript": "#3178c6",
+        "PHP": "#777bb4",
+        "Ruby": "#cc342d",
+        "Swift": "#fa7343",
+        "Kotlin": "#7f52ff",
+        "Scala": "#dc322f",
+        "R": "#276dc3",
+        "MATLAB": "#e16737"
+    }
+    
+    color = colors.get(language, "#6c757d")
+    return f"<span style='background: {color}; color: white; padding: 2px 8px; border-radius: 12px; font-size: 0.8em; font-weight: 500;'>{language}</span>"
+
+def format_taxonomy_badge(category: str) -> str:
+    """Format taxonomy category as a badge"""
+    if not category or category == "All":
+        return category
+    
+    # Category-specific colors
+    colors = {
+        "Bug Detection": "#dc3545",
+        "Code Style": "#6f42c1",
+        "Performance": "#fd7e14",
+        "Security": "#e83e8c",
+        "Maintainability": "#20c997",
+        "Documentation": "#17a2b8",
+        "Testing": "#28a745",
+        "Architecture": "#6c757d",
+        "Best Practices": "#007bff",
+        "Refactoring": "#ffc107"
+    }
+    
+    color = colors.get(category, "#6c757d")
+    return f"<span style='background: {color}; color: white; padding: 2px 8px; border-radius: 12px; font-size: 0.8em; font-weight: 500;'>{category}</span>"
+
+def format_comment_language_flag(language: str) -> str:
+    """Format comment language with flag emoji"""
+    if not language or language == "All":
+        return language
+    
+    # Language-specific flags
+    flags = {
+        "English": "🇺🇸",
+        "Chinese": "🇨🇳",
+        "Spanish": "🇪🇸",
+        "French": "🇫🇷",
+        "German": "🇩🇪",
+        "Japanese": "🇯🇵",
+        "Korean": "🇰🇷",
+        "Russian": "🇷🇺",
+        "Portuguese": "🇵🇹",
+        "Italian": "🇮🇹",
+        "Dutch": "🇳🇱"
+    }
+    
+    flag = flags.get(language, "🌐")
+    return f"{flag} {language}"
+
+def sanitize_html(text: str) -> str:
+    """Sanitize HTML content to prevent XSS"""
+    if not isinstance(text, str):
+        return str(text)
+    
+    # Remove potentially dangerous HTML tags
+    text = re.sub(r'<script[^>]*>.*?</script>', '', text, flags=re.DOTALL | re.IGNORECASE)
+    text = re.sub(r'<iframe[^>]*>.*?</iframe>', '', text, flags=re.DOTALL | re.IGNORECASE)
+    text = re.sub(r'on\w+="[^"]*"', '', text, flags=re.IGNORECASE)
+    text = re.sub(r'on\w+=\'[^\']*\'', '', text, flags=re.IGNORECASE)
+    
+    return text
+
+def truncate_text(text: str, max_length: int = 50) -> str:
+    """Truncate text with ellipsis"""
+    if not isinstance(text, str):
+        text = str(text)
+    
+    if len(text) <= max_length:
+        return text
+    
+    return text[:max_length-3] + "..."
+
+def format_table_cell(value: Any, column_name: str) -> str:
+    """Format table cell based on column type"""
+    if value is None:
+        return "N/A"
+    
+    # Handle different column types
+    if column_name.lower() in ["bleu", "pass@1", "pass@5", "pass@10"]:
+        return format_percentage(value)
+    elif column_name.lower() == "model":
+        return format_model_name(str(value))
+    elif column_name.lower() == "programming language":
+        return format_language_badge(str(value))
+    elif column_name.lower() == "comment language":
+        return format_comment_language_flag(str(value))
+    elif column_name.lower() == "taxonomy":
+        return format_taxonomy_badge(str(value))
+    elif column_name.lower() in ["readability", "relevance", "explanation clarity", 
+                                 "problem identification", "actionability", "completeness",
+                                 "specificity", "contextual adequacy", "consistency", "brevity"]:
+        return format_metric_score(value, column_name.lower())
+    else:
+        return sanitize_html(str(value)) 

src/display/utils.py

@@ -0,0 +1,292 @@
+"""
+Display utilities for the CodeReview Leaderboard
+"""
+
+from typing import List, Dict, Any, Optional, Tuple
+import json
+from datetime import datetime, timezone
+from src.envs import PROGRAMMING_LANGUAGES, COMMENT_LANGUAGES, TAXONOMY_CATEGORIES, QUALITY_METRICS
+from src.display.formatting import format_table_cell, format_timestamp
+
+def filter_leaderboard_data(
+    data: List[Dict],
+    programming_language: str = "All",
+    comment_language: str = "All", 
+    taxonomy_category: str = "All",
+    sort_by: str = "llm_pass_1",
+    sort_order: str = "desc"
+) -> List[Dict]:
+    """Filter and sort leaderboard data based on criteria"""
+    
+    if not data:
+        return []
+    
+    # Apply filters
+    filtered_data = data.copy()
+    
+    if programming_language != "All":
+        filtered_data = [
+            entry for entry in filtered_data
+            if entry.get("programming_language", "").lower() == programming_language.lower()
+        ]
+    
+    if comment_language != "All":
+        filtered_data = [
+            entry for entry in filtered_data
+            if entry.get("comment_language", "").lower() == comment_language.lower()
+        ]
+    
+    if taxonomy_category != "All":
+        filtered_data = [
+            entry for entry in filtered_data
+            if entry.get("taxonomy_category", "").lower() == taxonomy_category.lower()
+        ]
+    
+    # Sort data
+    reverse = sort_order.lower() == "desc"
+    
+    try:
+        if sort_by in ["bleu", "llm_pass_1", "llm_pass_5", "llm_pass_10"]:
+            filtered_data.sort(key=lambda x: x.get(sort_by, 0), reverse=reverse)
+        elif sort_by in QUALITY_METRICS:
+            filtered_data.sort(key=lambda x: x.get("metrics", {}).get(sort_by, 0), reverse=reverse)
+        else:
+            filtered_data.sort(key=lambda x: str(x.get(sort_by, "")), reverse=reverse)
+    except Exception as e:
+        print(f"Error sorting data: {e}")
+        # Default sort by pass@1
+        filtered_data.sort(key=lambda x: x.get("llm_pass_1", 0), reverse=True)
+    
+    return filtered_data
+
+def get_main_leaderboard_data(
+    data: List[Dict],
+    programming_language: str = "All",
+    comment_language: str = "All",
+    taxonomy_category: str = "All",
+    sort_by: str = "llm_pass_1"
+) -> List[List[str]]:
+    """Get formatted main leaderboard table data"""
+    
+    filtered_data = filter_leaderboard_data(
+        data, programming_language, comment_language, taxonomy_category, sort_by
+    )
+    
+    table_rows = []
+    for entry in filtered_data:
+        row = [
+            format_table_cell(entry.get("model_name", ""), "model"),
+            format_table_cell(entry.get("programming_language", ""), "programming language"),
+            format_table_cell(entry.get("comment_language", ""), "comment language"),
+            format_table_cell(entry.get("taxonomy_category", ""), "taxonomy"),
+            format_table_cell(entry.get("bleu", 0), "bleu"),
+            format_table_cell(entry.get("llm_pass_1", 0), "pass@1"),
+            format_table_cell(entry.get("llm_pass_5", 0), "pass@5"),
+            format_table_cell(entry.get("llm_pass_10", 0), "pass@10"),
+        ]
+        table_rows.append(row)
+    
+    return table_rows
+
+def get_quality_metrics_data(
+    data: List[Dict],
+    programming_language: str = "All",
+    comment_language: str = "All",
+    taxonomy_category: str = "All",
+    sort_by: str = "llm_pass_1"
+) -> List[List[str]]:
+    """Get formatted quality metrics table data"""
+    
+    filtered_data = filter_leaderboard_data(
+        data, programming_language, comment_language, taxonomy_category, sort_by
+    )
+    
+    table_rows = []
+    for entry in filtered_data:
+        metrics = entry.get("metrics", {})
+        row = [format_table_cell(entry.get("model_name", ""), "model")]
+        
+        for metric in QUALITY_METRICS:
+            formatted_value = format_table_cell(metrics.get(metric, 0), metric.replace("_", " "))
+            row.append(formatted_value)
+        
+        table_rows.append(row)
+    
+    return table_rows
+
+def get_submission_history_data(
+    data: List[Dict],
+    programming_language: str = "All",
+    comment_language: str = "All",
+    taxonomy_category: str = "All",
+    limit: int = 50
+) -> List[List[str]]:
+    """Get formatted submission history data"""
+    
+    filtered_data = filter_leaderboard_data(
+        data, programming_language, comment_language, taxonomy_category, "submission_date", "desc"
+    )
+    
+    # Limit results
+    filtered_data = filtered_data[:limit]
+    
+    table_rows = []
+    for entry in filtered_data:
+        row = [
+            format_table_cell(entry.get("model_name", ""), "model"),
+            format_table_cell(entry.get("programming_language", ""), "programming language"),
+            format_table_cell(entry.get("comment_language", ""), "comment language"),
+            format_table_cell(entry.get("taxonomy_category", ""), "taxonomy"),
+            format_table_cell(entry.get("llm_pass_1", 0), "pass@1"),
+            format_timestamp(entry.get("submission_date", "")),
+            entry.get("submission_ip", "").split(".")[0] + ".xxx.xxx.xxx" if entry.get("submission_ip") else "Unknown"
+        ]
+        table_rows.append(row)
+    
+    return table_rows
+
+def get_statistics_summary(data: List[Dict]) -> Dict[str, Any]:
+    """Get summary statistics for the leaderboard"""
+    
+    if not data:
+        return {
+            "total_models": 0,
+            "total_submissions": 0,
+            "avg_pass_1": 0,
+            "best_model": "None",
+            "languages_covered": 0,
+            "categories_covered": 0
+        }
+    
+    # Calculate statistics
+    total_models = len(set(entry.get("model_name", "") for entry in data))
+    total_submissions = len(data)
+    
+    pass_1_scores = [entry.get("llm_pass_1", 0) for entry in data if entry.get("llm_pass_1") is not None]
+    avg_pass_1 = sum(pass_1_scores) / len(pass_1_scores) if pass_1_scores else 0
+    
+    best_entry = max(data, key=lambda x: x.get("llm_pass_1", 0)) if data else None
+    best_model = best_entry.get("model_name", "None") if best_entry else "None"
+    
+    languages_covered = len(set(entry.get("programming_language", "") for entry in data if entry.get("programming_language")))
+    categories_covered = len(set(entry.get("taxonomy_category", "") for entry in data if entry.get("taxonomy_category")))
+    
+    return {
+        "total_models": total_models,
+        "total_submissions": total_submissions,
+        "avg_pass_1": avg_pass_1,
+        "best_model": best_model,
+        "languages_covered": languages_covered,
+        "categories_covered": categories_covered
+    }
+
+def validate_submission_data(data: Dict[str, Any]) -> Tuple[bool, str]:
+    """Validate submission data"""
+    
+    required_fields = ["model_name", "programming_language", "comment_language", "taxonomy_category"]
+    
+    # Check required fields
+    for field in required_fields:
+        if not data.get(field):
+            return False, f"Missing required field: {field}"
+    
+    # Validate scores
+    score_fields = ["bleu", "llm_pass_1", "llm_pass_5", "llm_pass_10"]
+    for field in score_fields:
+        value = data.get(field)
+        if value is None:
+            return False, f"Missing score: {field}"
+        if not isinstance(value, (int, float)):
+            return False, f"Invalid score format: {field}"
+        if not 0 <= value <= 1:
+            return False, f"Score out of range (0-1): {field}"
+    
+    # Validate metrics
+    metrics = data.get("metrics", {})
+    for metric in QUALITY_METRICS:
+        value = metrics.get(metric)
+        if value is None:
+            return False, f"Missing metric: {metric}"
+        if not isinstance(value, (int, float)):
+            return False, f"Invalid metric format: {metric}"
+        if not 0 <= value <= 10:
+            return False, f"Metric out of range (0-10): {metric}"
+    
+    # Validate language and category choices
+    if data.get("programming_language") not in PROGRAMMING_LANGUAGES:
+        return False, "Invalid programming language"
+    
+    if data.get("comment_language") not in COMMENT_LANGUAGES:
+        return False, "Invalid comment language"
+    
+    if data.get("taxonomy_category") not in TAXONOMY_CATEGORIES:
+        return False, "Invalid taxonomy category"
+    
+    return True, "Valid submission"
+
+def get_leaderboard_insights(data: List[Dict]) -> Dict[str, Any]:
+    """Get insights and trends from leaderboard data"""
+    
+    if not data:
+        return {}
+    
+    # Language performance analysis
+    lang_performance = {}
+    for lang in PROGRAMMING_LANGUAGES[1:]:  # Skip "All"
+        lang_data = [entry for entry in data if entry.get("programming_language") == lang]
+        if lang_data:
+            avg_score = sum(entry.get("llm_pass_1", 0) for entry in lang_data) / len(lang_data)
+            lang_performance[lang] = {
+                "avg_score": avg_score,
+                "model_count": len(lang_data),
+                "best_model": max(lang_data, key=lambda x: x.get("llm_pass_1", 0)).get("model_name", "")
+            }
+    
+    # Category performance analysis
+    category_performance = {}
+    for category in TAXONOMY_CATEGORIES[1:]:  # Skip "All"
+        cat_data = [entry for entry in data if entry.get("taxonomy_category") == category]
+        if cat_data:
+            avg_score = sum(entry.get("llm_pass_1", 0) for entry in cat_data) / len(cat_data)
+            category_performance[category] = {
+                "avg_score": avg_score,
+                "model_count": len(cat_data),
+                "best_model": max(cat_data, key=lambda x: x.get("llm_pass_1", 0)).get("model_name", "")
+            }
+    
+    return {
+        "language_performance": lang_performance,
+        "category_performance": category_performance,
+        "top_performers": sorted(data, key=lambda x: x.get("llm_pass_1", 0), reverse=True)[:5]
+    }
+
+def export_leaderboard_data(data: List[Dict], format_type: str = "json") -> str:
+    """Export leaderboard data in specified format"""
+    
+    if format_type.lower() == "json":
+        return json.dumps(data, indent=2, ensure_ascii=False)
+    elif format_type.lower() == "csv":
+        # Simple CSV export
+        if not data:
+            return ""
+        
+        # Get headers
+        headers = ["model_name", "programming_language", "comment_language", "taxonomy_category", 
+                  "bleu", "llm_pass_1", "llm_pass_5", "llm_pass_10"]
+        headers.extend(QUALITY_METRICS)
+        
+        lines = [",".join(headers)]
+        
+        for entry in data:
+            row = []
+            for header in headers:
+                if header in QUALITY_METRICS:
+                    value = entry.get("metrics", {}).get(header, "")
+                else:
+                    value = entry.get(header, "")
+                row.append(str(value))
+            lines.append(",".join(row))
+        
+        return "\n".join(lines)
+    else:
+        return "Unsupported format" 

src/envs.py

@@ -0,0 +1,106 @@
+"""
+Environment configuration and constants
+"""
+
+import os
+from pathlib import Path
+
+# Data paths
+DATA_DIR = Path("data")
+LEADERBOARD_PATH = DATA_DIR / "leaderboard_data.json"
+SUBMISSIONS_PATH = DATA_DIR / "submissions.json"
+
+# Create data directory if it doesn't exist
+DATA_DIR.mkdir(exist_ok=True)
+
+# Programming languages supported
+PROGRAMMING_LANGUAGES = [
+    "All",
+    "Python",
+    "JavaScript",
+    "Java",
+    "C++",
+    "C#",
+    "Go",
+    "Rust",
+    "TypeScript",
+    "PHP",
+    "Ruby",
+    "Swift",
+    "Kotlin",
+    "Scala",
+    "R",
+    "MATLAB",
+    "Other"
+]
+
+# Comment languages supported
+COMMENT_LANGUAGES = [
+    "All",
+    "English",
+    "Chinese",
+    "Spanish",
+    "French",
+    "German",
+    "Japanese",
+    "Korean",
+    "Russian",
+    "Portuguese",
+    "Italian",
+    "Dutch",
+    "Other"
+]
+
+# Taxonomy categories
+TAXONOMY_CATEGORIES = [
+    "All",
+    "Bug Detection",
+    "Code Style",
+    "Performance",
+    "Security",
+    "Maintainability",
+    "Documentation",
+    "Testing",
+    "Architecture",
+    "Best Practices",
+    "Refactoring",
+    "Other"
+]
+
+# Quality metrics
+QUALITY_METRICS = [
+    "readability",
+    "relevance", 
+    "explanation_clarity",
+    "problem_identification",
+    "actionability",
+    "completeness",
+    "specificity",
+    "contextual_adequacy",
+    "consistency",
+    "brevity"
+]
+
+# Table headers
+MAIN_HEADERS = ["Model", "Programming Language", "Comment Language", "Taxonomy", "BLEU", "Pass@1", "Pass@5", "Pass@10"]
+
+QUALITY_HEADERS = ["Model"] + [metric.replace("_", " ").title() for metric in QUALITY_METRICS]
+
+# Default data
+DEFAULT_DATA = [{
+    "model_name": "example/model",
+    "programming_language": "Python",
+    "comment_language": "English", 
+    "taxonomy_category": "Bug Detection",
+    "bleu": 0.5,
+    "llm_pass_1": 0.5,
+    "llm_pass_5": 0.5,
+    "llm_pass_10": 0.5,
+    "metrics": {
+        "readability": 5, "relevance": 5, "explanation_clarity": 5,
+        "problem_identification": 5, "actionability": 5, "completeness": 5,
+        "specificity": 5, "contextual_adequacy": 5, "consistency": 5, "brevity": 5
+    },
+    "submission_ip": "127.0.0.1",
+    "submission_date": "2024-01-01T00:00:00Z"
+}] 

src/leaderboard/__init__.py

@@ -0,0 +1 @@
+# Leaderboard processing module 

src/leaderboard/processor.py

@@ -0,0 +1,306 @@
+"""
+Leaderboard data processor for CodeReview Leaderboard
+"""
+
+import json
+import traceback
+from typing import List, Dict, Any, Optional
+from datetime import datetime, timezone, timedelta
+from pathlib import Path
+from src.envs import LEADERBOARD_PATH, SUBMISSIONS_PATH, DEFAULT_DATA
+from src.display.utils import validate_submission_data, get_statistics_summary
+
+class LeaderboardProcessor:
+    """Handles all leaderboard data operations"""
+    
+    def __init__(self):
+        self.leaderboard_path = LEADERBOARD_PATH
+        self.submissions_path = SUBMISSIONS_PATH
+        self._ensure_data_files()
+    
+    def _ensure_data_files(self):
+        """Ensure data files exist with default data"""
+        if not self.leaderboard_path.exists():
+            self.save_leaderboard_data(DEFAULT_DATA)
+        
+        if not self.submissions_path.exists():
+            self.save_submission_log([])
+    
+    def load_leaderboard_data(self) -> List[Dict]:
+        """Load leaderboard data from storage"""
+        try:
+            with open(self.leaderboard_path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+                return data.get("leaderboard", [])
+        except Exception as e:
+            print(f"Error loading leaderboard: {e}")
+            return DEFAULT_DATA.copy()
+    
+    def save_leaderboard_data(self, data: List[Dict]) -> bool:
+        """Save leaderboard data to storage"""
+        try:
+            to_store = {
+                "leaderboard": data,
+                "last_updated": datetime.now(timezone.utc).isoformat(),
+                "total_entries": len(data)
+            }
+            
+            with open(self.leaderboard_path, 'w', encoding='utf-8') as f:
+                json.dump(to_store, f, indent=2, ensure_ascii=False)
+            
+            return True
+        except Exception as e:
+            print(f"Error saving leaderboard: {e}")
+            return False
+    
+    def load_submission_log(self) -> List[Dict]:
+        """Load submission log from storage"""
+        try:
+            with open(self.submissions_path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+                return data.get("submissions", [])
+        except Exception as e:
+            print(f"Error loading submission log: {e}")
+            return []
+    
+    def save_submission_log(self, submissions: List[Dict]) -> bool:
+        """Save submission log to storage"""
+        try:
+            to_store = {
+                "submissions": submissions,
+                "last_updated": datetime.now(timezone.utc).isoformat(),
+                "total_submissions": len(submissions)
+            }
+            
+            with open(self.submissions_path, 'w', encoding='utf-8') as f:
+                json.dump(to_store, f, indent=2, ensure_ascii=False)
+            
+            return True
+        except Exception as e:
+            print(f"Error saving submission log: {e}")
+            return False
+    
+    def add_submission(self, submission_data: Dict[str, Any], ip_address: str) -> tuple[bool, str]:
+        """Add a new submission to the leaderboard"""
+        try:
+            # Validate submission data
+            is_valid, message = validate_submission_data(submission_data)
+            if not is_valid:
+                return False, message
+            
+            # Add metadata
+            submission_data["submission_ip"] = ip_address
+            submission_data["submission_date"] = datetime.now(timezone.utc).isoformat()
+            
+            # Load current data
+            current_data = self.load_leaderboard_data()
+            
+            # Check for existing model and replace if found
+            model_name = submission_data.get("model_name", "")
+            current_data = [entry for entry in current_data if entry.get("model_name") != model_name]
+            
+            # Add new submission
+            current_data.append(submission_data)
+            
+            # Save updated data
+            if self.save_leaderboard_data(current_data):
+                # Log the submission
+                self._log_submission(submission_data, ip_address)
+                return True, "✅ Submission recorded successfully!"
+            else:
+                return False, "❌ Failed to save submission"
+            
+        except Exception as e:
+            print(f"Error adding submission: {e}")
+            traceback.print_exc()
+            return False, f"❌ Submission failed: {str(e)}"
+    
+    def _log_submission(self, submission_data: Dict[str, Any], ip_address: str):
+        """Log submission for audit trail"""
+        try:
+            submissions = self.load_submission_log()
+            
+            log_entry = {
+                "model_name": submission_data.get("model_name"),
+                "programming_language": submission_data.get("programming_language"),
+                "comment_language": submission_data.get("comment_language"),
+                "taxonomy_category": submission_data.get("taxonomy_category"),
+                "scores": {
+                    "bleu": submission_data.get("bleu"),
+                    "llm_pass_1": submission_data.get("llm_pass_1"),
+                    "llm_pass_5": submission_data.get("llm_pass_5"),
+                    "llm_pass_10": submission_data.get("llm_pass_10")
+                },
+                "submission_ip": ip_address,
+                "submission_date": submission_data.get("submission_date"),
+                "status": "accepted"
+            }
+            
+            submissions.append(log_entry)
+            
+            # Keep only last 1000 submissions
+            submissions = submissions[-1000:]
+            
+            self.save_submission_log(submissions)
+            
+        except Exception as e:
+            print(f"Error logging submission: {e}")
+    
+    def get_model_history(self, model_name: str) -> List[Dict]:
+        """Get submission history for a specific model"""
+        try:
+            submissions = self.load_submission_log()
+            return [
+                sub for sub in submissions 
+                if sub.get("model_name") == model_name
+            ]
+        except Exception as e:
+            print(f"Error getting model history: {e}")
+            return []
+    
+    def get_ip_submissions(self, ip_address: str, limit: int = 10) -> List[Dict]:
+        """Get recent submissions from a specific IP"""
+        try:
+            submissions = self.load_submission_log()
+            ip_submissions = [
+                sub for sub in submissions 
+                if sub.get("submission_ip") == ip_address
+            ]
+            
+            # Sort by date and limit
+            ip_submissions.sort(key=lambda x: x.get("submission_date", ""), reverse=True)
+            return ip_submissions[:limit]
+            
+        except Exception as e:
+            print(f"Error getting IP submissions: {e}")
+            return []
+    
+    def check_rate_limit(self, ip_address: str, max_submissions: int = 5, hours: int = 24) -> tuple[bool, str]:
+        """Check if IP has exceeded rate limit"""
+        try:
+            submissions = self.get_ip_submissions(ip_address, max_submissions * 2)
+            
+            # Count submissions within the time window
+            cutoff_time = datetime.now(timezone.utc) - timedelta(hours=hours)
+            recent_submissions = [
+                sub for sub in submissions
+                if datetime.fromisoformat(sub.get("submission_date", "")).replace(tzinfo=timezone.utc) > cutoff_time
+            ]
+            
+            if len(recent_submissions) >= max_submissions:
+                return False, f"Rate limit exceeded: {len(recent_submissions)}/{max_submissions} submissions in {hours} hours"
+            
+            return True, f"Rate limit OK: {len(recent_submissions)}/{max_submissions} submissions in {hours} hours"
+            
+        except Exception as e:
+            print(f"Error checking rate limit: {e}")
+            return True, "Rate limit check failed, allowing submission"
+    
+    def get_leaderboard_stats(self) -> Dict[str, Any]:
+        """Get comprehensive leaderboard statistics"""
+        try:
+            data = self.load_leaderboard_data()
+            submissions = self.load_submission_log()
+            
+            basic_stats = get_statistics_summary(data)
+            
+            # Additional stats
+            recent_submissions = len([
+                sub for sub in submissions
+                if datetime.fromisoformat(sub.get("submission_date", "")).replace(tzinfo=timezone.utc) > 
+                   datetime.now(timezone.utc) - timedelta(days=7)
+            ])
+            
+            return {
+                **basic_stats,
+                "recent_submissions_7d": recent_submissions,
+                "total_logged_submissions": len(submissions),
+                "last_updated": datetime.now(timezone.utc).isoformat()
+            }
+            
+        except Exception as e:
+            print(f"Error getting leaderboard stats: {e}")
+            return {}
+    
+    def backup_data(self) -> bool:
+        """Create backup of current data"""
+        try:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            backup_dir = Path("backups")
+            backup_dir.mkdir(exist_ok=True)
+            
+            # Backup leaderboard
+            if self.leaderboard_path.exists():
+                backup_path = backup_dir / f"leaderboard_{timestamp}.json"
+                with open(self.leaderboard_path, 'r') as src, open(backup_path, 'w') as dst:
+                    dst.write(src.read())
+            
+            # Backup submissions
+            if self.submissions_path.exists():
+                backup_path = backup_dir / f"submissions_{timestamp}.json"
+                with open(self.submissions_path, 'r') as src, open(backup_path, 'w') as dst:
+                    dst.write(src.read())
+            
+            return True
+            
+        except Exception as e:
+            print(f"Error creating backup: {e}")
+            return False
+    
+    def export_data(self, format_type: str = "json") -> str:
+        """Export leaderboard data in specified format"""
+        try:
+            from src.display.utils import export_leaderboard_data
+            
+            data = self.load_leaderboard_data()
+            return export_leaderboard_data(data, format_type)
+            
+        except Exception as e:
+            print(f"Error exporting data: {e}")
+            return f"Export failed: {str(e)}"
+    
+    def validate_data_integrity(self) -> Dict[str, Any]:
+        """Validate data integrity and return report"""
+        try:
+            data = self.load_leaderboard_data()
+            submissions = self.load_submission_log()
+            
+            issues = []
+            
+            # Check for duplicate models
+            model_names = [entry.get("model_name") for entry in data]
+            duplicates = [name for name in model_names if model_names.count(name) > 1]
+            if duplicates:
+                issues.append(f"Duplicate models found: {set(duplicates)}")
+            
+            # Check for missing required fields
+            required_fields = ["model_name", "programming_language", "comment_language", "taxonomy_category"]
+            for i, entry in enumerate(data):
+                missing = [field for field in required_fields if not entry.get(field)]
+                if missing:
+                    issues.append(f"Entry {i}: Missing fields {missing}")
+            
+            # Check score ranges
+            for i, entry in enumerate(data):
+                scores = ["bleu", "llm_pass_1", "llm_pass_5", "llm_pass_10"]
+                for score in scores:
+                    value = entry.get(score)
+                    if value is not None and (value < 0 or value > 1):
+                        issues.append(f"Entry {i}: {score} out of range: {value}")
+            
+            return {
+                "is_valid": len(issues) == 0,
+                "issues": issues,
+                "total_entries": len(data),
+                "total_submissions": len(submissions),
+                "check_date": datetime.now(timezone.utc).isoformat()
+            }
+            
+        except Exception as e:
+            return {
+                "is_valid": False,
+                "issues": [f"Validation failed: {str(e)}"],
+                "total_entries": 0,
+                "total_submissions": 0,
+                "check_date": datetime.now(timezone.utc).isoformat()
+            } 

src/submission/__init__.py

@@ -0,0 +1 @@
+# Submission handling module 

src/submission/submit.py

@@ -0,0 +1,386 @@
+"""
+Submission system for CodeReview Leaderboard
+"""
+
+import gradio as gr
+import re
+from typing import Dict, Any, List, Tuple
+from datetime import datetime, timezone
+from src.envs import PROGRAMMING_LANGUAGES, COMMENT_LANGUAGES, TAXONOMY_CATEGORIES, QUALITY_METRICS
+from src.leaderboard.processor import LeaderboardProcessor
+from src.display.utils import get_main_leaderboard_data, get_quality_metrics_data
+
+class SubmissionHandler:
+    """Handles model submissions with validation and rate limiting"""
+    
+    def __init__(self):
+        self.processor = LeaderboardProcessor()
+    
+    def get_client_ip(self, request: gr.Request) -> str:
+        """Extract client IP address from request"""
+        try:
+            # Check for forwarded headers first
+            forwarded_for = request.headers.get('X-Forwarded-For')
+            if forwarded_for:
+                # Take the first IP if multiple
+                ip = forwarded_for.split(',')[0].strip()
+                return ip
+            
+            # Check for real IP header
+            real_ip = request.headers.get('X-Real-IP')
+            if real_ip:
+                return real_ip.strip()
+            
+            # Fall back to client host
+            if hasattr(request, 'client') and hasattr(request.client, 'host'):
+                return request.client.host
+            
+            # Default fallback
+            return "127.0.0.1"
+            
+        except Exception as e:
+            print(f"Error getting client IP: {e}")
+            return "127.0.0.1"
+    
+    def validate_model_name(self, model_name: str) -> Tuple[bool, str]:
+        """Validate model name format"""
+        if not model_name or not model_name.strip():
+            return False, "Model name cannot be empty"
+        
+        model_name = model_name.strip()
+        
+        # Check length
+        if len(model_name) > 100:
+            return False, "Model name too long (max 100 characters)"
+        
+        # Check for valid characters
+        if not re.match(r'^[a-zA-Z0-9._/-]+$', model_name):
+            return False, "Model name contains invalid characters (only letters, numbers, dots, hyphens, underscores, and slashes allowed)"
+        
+        # Check for organization/model format
+        if "/" in model_name:
+            parts = model_name.split("/")
+            if len(parts) != 2:
+                return False, "Model name should be in format 'organization/model'"
+            if not parts[0] or not parts[1]:
+                return False, "Both organization and model name must be specified"
+        
+        return True, "Valid model name"
+    
+    def validate_scores(self, scores: Dict[str, float]) -> Tuple[bool, str]:
+        """Validate score values"""
+        required_scores = ["bleu", "llm_pass_1", "llm_pass_5", "llm_pass_10"]
+        
+        for score_name in required_scores:
+            value = scores.get(score_name)
+            
+            if value is None:
+                return False, f"Missing score: {score_name}"
+            
+            if not isinstance(value, (int, float)):
+                return False, f"Invalid score format for {score_name}: must be a number"
+            
+            if not (0 <= value <= 1):
+                return False, f"Score {score_name} out of range: {value} (must be between 0 and 1)"
+        
+        # Check logical consistency
+        if scores["llm_pass_1"] > scores["llm_pass_5"]:
+            return False, "Pass@1 score cannot be higher than Pass@5"
+        
+        if scores["llm_pass_5"] > scores["llm_pass_10"]:
+            return False, "Pass@5 score cannot be higher than Pass@10"
+        
+        return True, "Valid scores"
+    
+    def validate_metrics(self, metrics: Dict[str, int]) -> Tuple[bool, str]:
+        """Validate quality metrics"""
+        for metric_name in QUALITY_METRICS:
+            value = metrics.get(metric_name)
+            
+            if value is None:
+                return False, f"Missing metric: {metric_name}"
+            
+            if not isinstance(value, (int, float)):
+                return False, f"Invalid metric format for {metric_name}: must be a number"
+            
+            if not (0 <= value <= 10):
+                return False, f"Metric {metric_name} out of range: {value} (must be between 0 and 10)"
+        
+        return True, "Valid metrics"
+    
+    def submit_model(
+        self,
+        request: gr.Request,
+        current_data: List[Dict],
+        model_name: str,
+        programming_language: str,
+        comment_language: str,
+        taxonomy_category: str,
+        bleu: float,
+        llm_pass_1: float,
+        llm_pass_5: float,
+        llm_pass_10: float,
+        readability: int,
+        relevance: int,
+        explanation_clarity: int,
+        problem_identification: int,
+        actionability: int,
+        completeness: int,
+        specificity: int,
+        contextual_adequacy: int,
+        consistency: int,
+        brevity: int,
+    ) -> Tuple[List[Dict], List[List[str]], List[List[str]], str]:
+        """Handle model submission with full validation"""
+        
+        try:
+            # Get client IP
+            client_ip = self.get_client_ip(request)
+            
+            # Check rate limiting
+            rate_ok, rate_msg = self.processor.check_rate_limit(client_ip)
+            if not rate_ok:
+                return current_data, [], [], f"❌ {rate_msg}"
+            
+            # Validate model name
+            name_valid, name_msg = self.validate_model_name(model_name)
+            if not name_valid:
+                return current_data, [], [], f"❌ {name_msg}"
+            
+            # Validate scores
+            scores = {
+                "bleu": bleu,
+                "llm_pass_1": llm_pass_1,
+                "llm_pass_5": llm_pass_5,
+                "llm_pass_10": llm_pass_10
+            }
+            scores_valid, scores_msg = self.validate_scores(scores)
+            if not scores_valid:
+                return current_data, [], [], f"❌ {scores_msg}"
+            
+            # Validate metrics
+            metrics = {
+                "readability": readability,
+                "relevance": relevance,
+                "explanation_clarity": explanation_clarity,
+                "problem_identification": problem_identification,
+                "actionability": actionability,
+                "completeness": completeness,
+                "specificity": specificity,
+                "contextual_adequacy": contextual_adequacy,
+                "consistency": consistency,
+                "brevity": brevity,
+            }
+            metrics_valid, metrics_msg = self.validate_metrics(metrics)
+            if not metrics_valid:
+                return current_data, [], [], f"❌ {metrics_msg}"
+            
+            # Create submission data
+            submission_data = {
+                "model_name": model_name.strip(),
+                "programming_language": programming_language,
+                "comment_language": comment_language,
+                "taxonomy_category": taxonomy_category,
+                "bleu": bleu,
+                "llm_pass_1": llm_pass_1,
+                "llm_pass_5": llm_pass_5,
+                "llm_pass_10": llm_pass_10,
+                "metrics": metrics
+            }
+            
+            # Submit to processor
+            success, message = self.processor.add_submission(submission_data, client_ip)
+            
+            if success:
+                # Load updated data
+                updated_data = self.processor.load_leaderboard_data()
+                
+                # Format tables
+                main_table = get_main_leaderboard_data(updated_data)
+                quality_table = get_quality_metrics_data(updated_data)
+                
+                return updated_data, main_table, quality_table, message
+            else:
+                return current_data, [], [], message
+                
+        except Exception as e:
+            print(f"Error in submission: {e}")
+            return current_data, [], [], f"❌ Submission failed: {str(e)}"
+    
+    def get_submission_form_components(self):
+        """Create gradio components for submission form"""
+        
+        with gr.Accordion("📝 Submit New Model Results", open=False):
+            gr.Markdown("""
+            ### Submission Guidelines
+            - Provide accurate scores based on proper evaluation
+            - Model name should follow 'organization/model' format
+            - All metrics are required
+            - Submissions are rate-limited per IP address
+            """)
+            
+            with gr.Row():
+                model_name = gr.Textbox(
+                    label="Model Name",
+                    placeholder="e.g., microsoft/CodeT5-base",
+                    info="Use organization/model format"
+                )
+                programming_language = gr.Dropdown(
+                    choices=PROGRAMMING_LANGUAGES,
+                    value="All",
+                    label="Programming Language",
+                    info="Primary programming language evaluated"
+                )
+                comment_language = gr.Dropdown(
+                    choices=COMMENT_LANGUAGES,
+                    value="English",
+                    label="Comment Language",
+                    info="Natural language of code comments"
+                )
+                taxonomy_category = gr.Dropdown(
+                    choices=TAXONOMY_CATEGORIES,
+                    value="All",
+                    label="Taxonomy Category",
+                    info="Primary review category focus"
+                )
+            
+            gr.Markdown("### 📊 Performance Scores (0.0 - 1.0)")
+            with gr.Row():
+                bleu = gr.Number(
+                    label="BLEU Score",
+                    value=0.0,
+                    minimum=0.0,
+                    maximum=1.0,
+                    step=0.001,
+                    info="BLEU similarity score"
+                )
+                pass1 = gr.Number(
+                    label="Pass@1",
+                    value=0.0,
+                    minimum=0.0,
+                    maximum=1.0,
+                    step=0.001,
+                    info="Success rate in 1 attempt"
+                )
+                pass5 = gr.Number(
+                    label="Pass@5",
+                    value=0.0,
+                    minimum=0.0,
+                    maximum=1.0,
+                    step=0.001,
+                    info="Success rate in 5 attempts"
+                )
+                pass10 = gr.Number(
+                    label="Pass@10",
+                    value=0.0,
+                    minimum=0.0,
+                    maximum=1.0,
+                    step=0.001,
+                    info="Success rate in 10 attempts"
+                )
+            
+            gr.Markdown("### 📋 Quality Metrics (0 - 10)")
+            with gr.Row():
+                readability = gr.Slider(
+                    minimum=0, maximum=10, value=5, step=1,
+                    label="Readability",
+                    info="How readable are the generated reviews?"
+                )
+                relevance = gr.Slider(
+                    minimum=0, maximum=10, value=5, step=1,
+                    label="Relevance",
+                    info="How relevant to the code changes?"
+                )
+                explanation_clarity = gr.Slider(
+                    minimum=0, maximum=10, value=5, step=1,
+                    label="Explanation Clarity",
+                    info="How clear are the explanations?"
+                )
+                problem_identification = gr.Slider(
+                    minimum=0, maximum=10, value=5, step=1,
+                    label="Problem Identification",
+                    info="How well does it identify issues?"
+                )
+                actionability = gr.Slider(
+                    minimum=0, maximum=10, value=5, step=1,
+                    label="Actionability",
+                    info="How actionable are the suggestions?"
+                )
+            
+            with gr.Row():
+                completeness = gr.Slider(
+                    minimum=0, maximum=10, value=5, step=1,
+                    label="Completeness",
+                    info="How complete are the reviews?"
+                )
+                specificity = gr.Slider(
+                    minimum=0, maximum=10, value=5, step=1,
+                    label="Specificity",
+                    info="How specific are the comments?"
+                )
+                contextual_adequacy = gr.Slider(
+                    minimum=0, maximum=10, value=5, step=1,
+                    label="Contextual Adequacy",
+                    info="How well does it understand context?"
+                )
+                consistency = gr.Slider(
+                    minimum=0, maximum=10, value=5, step=1,
+                    label="Consistency",
+                    info="How consistent across reviews?"
+                )
+                brevity = gr.Slider(
+                    minimum=0, maximum=10, value=5, step=1,
+                    label="Brevity",
+                    info="How concise are the reviews?"
+                )
+            
+            submit_btn = gr.Button("🚀 Submit Model", variant="primary")
+            status_msg = gr.Markdown("")
+            
+            # Return all components for use in the main app
+            return {
+                "model_name": model_name,
+                "programming_language": programming_language,
+                "comment_language": comment_language,
+                "taxonomy_category": taxonomy_category,
+                "bleu": bleu,
+                "pass1": pass1,
+                "pass5": pass5,
+                "pass10": pass10,
+                "readability": readability,
+                "relevance": relevance,
+                "explanation_clarity": explanation_clarity,
+                "problem_identification": problem_identification,
+                "actionability": actionability,
+                "completeness": completeness,
+                "specificity": specificity,
+                "contextual_adequacy": contextual_adequacy,
+                "consistency": consistency,
+                "brevity": brevity,
+                "submit_btn": submit_btn,
+                "status_msg": status_msg,
+            }
+    
+    def get_submission_history(self, ip_address: str) -> List[List[str]]:
+        """Get submission history for display"""
+        try:
+            submissions = self.processor.get_ip_submissions(ip_address)
+            
+            table_data = []
+            for sub in submissions:
+                row = [
+                    sub.get("model_name", ""),
+                    sub.get("programming_language", ""),
+                    sub.get("comment_language", ""),
+                    sub.get("taxonomy_category", ""),
+                    f"{sub.get('scores', {}).get('llm_pass_1', 0):.3f}",
+                    sub.get("submission_date", "").split("T")[0] if sub.get("submission_date") else "",
+                    sub.get("status", "")
+                ]
+                table_data.append(row)
+            
+            return table_data
+            
+        except Exception as e:
+            print(f"Error getting submission history: {e}")
+            return []