simplify and unpin

app.py

@@ -1,44 +1,87 @@
 import datetime
 import os
 import re
-
-import gradio as gr
-import pandas as pd
 import yaml
+from datasets import Dataset, load_dataset
+from huggingface_hub import create_repo, login
+import gradio as gr
 
 # Constants
-EVAL_CARDS_DIR = "eval_cards"
-TEMPLATE_PATH = "template.yaml"
-
-
-# Ensure the eval cards directory exists
-os.makedirs(EVAL_CARDS_DIR, exist_ok=True)
-
-# Copy the template to the appropriate location
-with open("template.yaml", "w") as f:
-    with open("yaml_template.yaml", "r") as template_file:
-        f.write(template_file.read())
+DATASET_NAME = "jablonkagroup/eval-cards-dataset"
 
 
-def load_template():
-    """Load the YAML template"""
-    with open(TEMPLATE_PATH, "r") as file:
-        return file.read()
+def setup_hf_auth():
+    """Setup Hugging Face authentication"""
+    try:
+        hf_token = os.environ.get("HF_TOKEN")
+        if hf_token:
+            login(token=hf_token)
+            return True
+        return False
+    except Exception:
+        return False
 
 
-def yaml_to_dict(yaml_str):
-    """Convert YAML string to Python dictionary"""
+def ensure_dataset_exists():
+    """Ensure the dataset repository exists"""
     try:
-        return yaml.safe_load(yaml_str)
-    except yaml.YAMLError as e:
-        return {"error": str(e)}
+        load_dataset(DATASET_NAME, split="train")
+        return True
+    except Exception:
+        try:
+            if not setup_hf_auth():
+                return False
+            create_repo(
+                repo_id=DATASET_NAME, repo_type="dataset", private=False, exist_ok=True
+            )
+            empty_data = {
+                "filename": [],
+                "title": [],
+                "summary": [],
+                "authors": [],
+                "creation_date": [],
+                "coverage_score": [],
+                "yaml_content": [],
+                "paper_link": [],
+                "repository_link": [],
+                "timestamp": [],
+            }
+            empty_dataset = Dataset.from_dict(empty_data)
+            empty_dataset.push_to_hub(DATASET_NAME)
+            return True
+        except Exception:
+            return False
+
+
+def get_template():
+    """Get a basic YAML template"""
+    return """title: "Your Evaluation Title"
+summary: "Brief description of your evaluation"
+metadata:
+  authors: []
+  creation_date: ""
+evaluation_design:
+  purpose: ""
+  scope: ""
+estimand:
+  definition: ""
+estimator:
+  method: ""
+estimate:
+  results: ""
+results_communication:
+  format: ""
+known_issues_and_limitations:
+  issues: []
+version_and_maintenance:
+  version: "1.0"
+citation_and_usage:
+  citation: ""
+"""
 
 
 def compute_coverage_score(eval_data):
-    """
-    Compute a coverage score for the eval card
-    Returns a score from 0-100 and a breakdown of coverage by section
-    """
+    """Compute a coverage score for the eval card"""
     sections = {
         "metadata": 5,
         "evaluation_design": 10,
@@ -51,32 +94,23 @@ def compute_coverage_score(eval_data):
         "citation_and_usage": 5,
     }
 
-    scores = {}
-    total_score = 0
-
-    def count_filled_fields(data, prefix=""):
+    def count_filled_fields(data):
         if isinstance(data, dict):
-            filled = 0
-            total = 0
-            for key, value in data.items():
+            filled = total = 0
+            for value in data.values():
                 if isinstance(value, (dict, list)):
-                    sub_filled, sub_total = count_filled_fields(
-                        value, f"{prefix}.{key}" if prefix else key
-                    )
+                    sub_filled, sub_total = count_filled_fields(value)
                     filled += sub_filled
                     total += sub_total
                 else:
                     total += 1
-                    if value and not (
-                        isinstance(value, str) and value.strip() in ["", "[]", "{}"]
-                    ):
+                    if value and str(value).strip() not in ["", "[]", "{}"]:
                         filled += 1
             return filled, total
         elif isinstance(data, list):
             if not data:
                 return 0, 1
-            filled = 0
-            total = 0
+            filled = total = 0
             for item in data:
                 sub_filled, sub_total = count_filled_fields(item)
                 filled += sub_filled
@@ -85,426 +119,255 @@ def compute_coverage_score(eval_data):
         else:
             return 1 if data else 0, 1
 
-    # Compute scores for each section
+    total_score = 0
     for section, weight in sections.items():
         if section in eval_data:
             filled, total = count_filled_fields(eval_data[section])
             completion_rate = filled / total if total > 0 else 0
-            scores[section] = {
-                "score": round(completion_rate * weight, 2),
-                "max_score": weight,
-                "completion_rate": round(completion_rate * 100, 2),
-                "fields_filled": filled,
-                "fields_total": total,
-            }
-            total_score += scores[section]["score"]
-        else:
-            scores[section] = {
-                "score": 0,
-                "max_score": weight,
-                "completion_rate": 0,
-                "fields_filled": 0,
-                "fields_total": 0,
-            }
+            total_score += completion_rate * weight
 
-    return min(round(total_score, 2), 100), scores
+    return min(round(total_score, 2), 100)
 
 
-def get_llm_feedback(yaml_content, api_token=None):
-    """
-    Get feedback on the eval card from Groq's LLM
-    Uses GROQ_API_KEY from environment variables if no token is provided
-    """
-    import os
+def save_eval_card(yaml_content, paper_url="", repo_url=""):
+    """Save an eval card to the dataset"""
+    try:
+        if not setup_hf_auth():
+            return "Error: HF_TOKEN not found. Please set your Hugging Face token in Space settings."
 
-    import requests
-    from dotenv import load_dotenv
+        eval_data = yaml.safe_load(yaml_content)
 
-    # Load environment variables from .env file if it exists
-    load_dotenv()
+        if paper_url:
+            eval_data.setdefault("metadata", {})["paper_link"] = paper_url
+        if repo_url:
+            eval_data.setdefault("metadata", {})["repository_link"] = repo_url
 
-    # Use provided token or get from environment
-    api_token = api_token or os.environ.get("GROQ_API_KEY")
+        yaml_content = yaml.dump(eval_data)
+        filename = re.sub(r"[^\w\-_]", "_", eval_data.get("title", "Unnamed"))
+        filename = (
+            f"{filename}_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.yaml"
+        )
 
-    if not api_token:
-        return "API token is required for LLM feedback. Please set the GROQ_API_KEY environment variable or provide a token."
+        try:
+            dataset = load_dataset(DATASET_NAME, split="train")
+            existing_data = dataset.to_dict()
+        except Exception:
+            existing_data = {
+                "filename": [],
+                "title": [],
+                "summary": [],
+                "authors": [],
+                "creation_date": [],
+                "coverage_score": [],
+                "yaml_content": [],
+                "paper_link": [],
+                "repository_link": [],
+                "timestamp": [],
+            }
 
-    try:
-        headers = {
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {api_token}",
-        }
-
-        prompt = f"""
-        I'm reviewing an Evaluation Card in YAML format. Please analyze it for completeness, 
-        consistency, and clarity. Provide specific recommendations for improvement.
-        
-        Focus on:
-        1. Sections that need more detail
-        2. Inconsistencies or contradictions
-        3. Clarity of language and explanations
-        4. Alignment with best practices for ML evaluation
-        
-        Here's the YAML content:
-        
-        ```yaml
-        {yaml_content}
-        ```
-        
-        Provide your feedback in a structured format with specific, actionable recommendations.
-        """
-
-        payload = {
-            "model": "llama-3.3-70b-versatile",  # or another groq supported model
-            "messages": [{"role": "user", "content": prompt}],
-        }
+        score = compute_coverage_score(eval_data)
 
-        response = requests.post(
-            "https://api.groq.com/openai/v1/chat/completions",
-            headers=headers,
-            json=payload,
+        existing_data["filename"].append(filename)
+        existing_data["title"].append(eval_data.get("title", "Unnamed"))
+        existing_data["summary"].append(eval_data.get("summary", ""))
+        existing_data["authors"].append(
+            ", ".join(eval_data.get("metadata", {}).get("authors", []))
+        )
+        existing_data["creation_date"].append(
+            eval_data.get("metadata", {}).get("creation_date", "")
         )
+        existing_data["coverage_score"].append(float(score))
+        existing_data["yaml_content"].append(yaml_content)
+        existing_data["paper_link"].append(paper_url or "")
+        existing_data["repository_link"].append(repo_url or "")
+        existing_data["timestamp"].append(datetime.datetime.now().isoformat())
 
-        if response.status_code == 200:
-            return response.json()["choices"][0]["message"]["content"]
-        else:
-            return f"Error getting Groq LLM feedback: {response.status_code} - {response.text}"
+        updated_dataset = Dataset.from_dict(existing_data)
+        updated_dataset.push_to_hub(DATASET_NAME)
+
+        return f"✅ Successfully saved! Coverage score: {score}%\nFilename: {filename}"
 
     except Exception as e:
-        return f"Error getting Groq LLM feedback: {str(e)}"
+        return f"❌ Error: {str(e)}"
 
 
-def save_eval_card(yaml_content, paper_url="", repo_url=""):
-    """Save an eval card with additional metadata"""
+def load_gallery():
+    """Load all evaluation cards from dataset"""
     try:
-        eval_data = yaml.safe_load(yaml_content)
+        if not setup_hf_auth():
+            return "Please set HF_TOKEN in Space settings to view gallery."
 
-        # Add paper and repository links to metadata
-        if paper_url:
-            eval_data["metadata"]["paper_link"] = paper_url
-        if repo_url:
-            eval_data["metadata"]["repository_link"] = repo_url
+        if not ensure_dataset_exists():
+            return "Dataset not accessible. Please check HF_TOKEN."
 
-        # Update the YAML content with the new metadata
-        yaml_content = yaml.dump(eval_data)
+        dataset = load_dataset(DATASET_NAME, split="train")
 
-        filename = re.sub(r"[^\w\-_]", "_", eval_data.get("title", "Unnamed"))
-        filename = (
-            f"{filename}_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.yaml"
+        if len(dataset) == 0:
+            return "No evaluation cards found. Submit your first card!"
+
+        cards_html = "<h3>📊 Evaluation Cards Gallery</h3>"
+
+        # Sort by coverage score
+        sorted_indices = sorted(
+            range(len(dataset)),
+            key=lambda i: dataset[i]["coverage_score"],
+            reverse=True,
         )
-        file_path = os.path.join(EVAL_CARDS_DIR, filename)
 
-        with open(file_path, "w") as file:
-            file.write(yaml_content)
+        for i in sorted_indices[:10]:  # Show top 10
+            row = dataset[i]
+            cards_html += f"""
+            <div style="border: 1px solid #ddd; padding: 15px; margin: 10px 0; border-radius: 8px; background-color: #f9f9f9;">
+                <h4>🎯 {row["title"]}</h4>
+                <p><strong>Summary:</strong> {row["summary"]}</p>
+                <p><strong>Authors:</strong> {row["authors"]}</p>
+                <p><strong>Coverage Score:</strong> <span style="color: #2e7d32; font-weight: bold;">{row["coverage_score"]}%</span></p>
+                <p><strong>Created:</strong> {row["creation_date"]}</p>
+                {f'<p><strong>📄 Paper:</strong> <a href="{row["paper_link"]}" target="_blank">View</a></p>' if row.get("paper_link") else ""}
+                {f'<p><strong>💻 Repository:</strong> <a href="{row["repository_link"]}" target="_blank">View</a></p>' if row.get("repository_link") else ""}
+            </div>
+            """
+
+        return cards_html
 
-        return f"Evaluation card saved successfully as {filename}", file_path
     except Exception as e:
-        return f"Error saving evaluation card: {str(e)}", None
-
-
-def load_all_eval_cards():
-    """Load all eval cards from the repository"""
-    eval_cards = []
-
-    for filename in os.listdir(EVAL_CARDS_DIR):
-        if filename.endswith(".yaml"):
-            file_path = os.path.join(EVAL_CARDS_DIR, filename)
-            try:
-                with open(file_path, "r") as file:
-                    yaml_content = file.read()
-                    eval_data = yaml.safe_load(yaml_content)
-
-                    # Compute coverage score
-                    score, score_details = compute_coverage_score(eval_data)
-                    score = min(score, 100)
-
-                    # Extract key metadata
-                    eval_cards.append(
-                        {
-                            "filename": filename,
-                            "title": eval_data.get("title", "Unnamed Evaluation"),
-                            "summary": eval_data.get("summary", ""),
-                            "authors": ", ".join(
-                                eval_data.get("metadata", {}).get("authors", [])
-                            ),
-                            "creation_date": eval_data.get("metadata", {}).get(
-                                "creation_date", ""
-                            ),
-                            "coverage_score": score,
-                            "score_details": score_details,
-                            "yaml_content": yaml_content,
-                            "data": eval_data,
-                        }
-                    )
-            except Exception as e:
-                print(f"Error loading {filename}: {str(e)}")
-
-    return eval_cards
-
-
-def format_eval_card_as_html(eval_card):
-    """Format an eval card as HTML for display"""
-    html = f"""
-    <div style="border: 1px solid #ddd; padding: 15px; margin-bottom: 20px; border-radius: 5px;">
-        <h3>{eval_card["title"]}</h3>
-        <p>{eval_card["summary"]}</p>
-        <p><strong>Authors:</strong> {eval_card["authors"]}</p>
-        <p><strong>Created:</strong> {eval_card["creation_date"]}</p>
-        
-        <!-- Add repository and paper links if available -->
-        {f'<p><strong>Repository:</strong> <a href="{eval_card["data"]["metadata"].get("repository_link", "")}" target="_blank">{eval_card["data"]["metadata"].get("repository_link", "")}</a></p>' if eval_card["data"]["metadata"].get("repository_link") else ""}
-        {f'<p><strong>Paper:</strong> <a href="{eval_card["data"]["metadata"].get("paper_link", "")}" target="_blank">{eval_card["data"]["metadata"].get("paper_link", "")}</a></p>' if eval_card["data"]["metadata"].get("paper_link") else ""}
-        
-        <p><strong>Coverage Score:</strong> {eval_card["coverage_score"]}%</p>
-        
-        <h4>Coverage by Section:</h4>
-        <table style="width: 100%; border-collapse: collapse;">
-            <tr>
-                <th style="text-align: left; padding: 5px; border-bottom: 1px solid #ddd;">Section</th>
-                <th style="text-align: right; padding: 5px; border-bottom: 1px solid #ddd;">Score</th>
-                <th style="text-align: right; padding: 5px; border-bottom: 1px solid #ddd;">Completion</th>
-            </tr>
-    """
-
-    for section, details in eval_card["score_details"].items():
-        html += f"""
-            <tr>
-                <td style="padding: 5px; border-bottom: 1px solid #eee;">{section}</td>
-                <td style="text-align: right; padding: 5px; border-bottom: 1px solid #eee;">{details["score"]}/{details["max_score"]}</td>
-                <td style="text-align: right; padding: 5px; border-bottom: 1px solid #eee;">{details["completion_rate"]}%</td>
-            </tr>
-        """
-
-    html += """
-        </table>
-        <div style="margin-top: 15px;">
-            <!-- Additional actions can go here -->
-        </div>
-    </div>
-    """
-
-    return html
-
-
-def create_eval_cards_table(eval_cards):
-    """Create an HTML table of eval cards"""
-    if not eval_cards:
-        return "<p>No evaluation cards found.</p>"
-
-    # Sort by coverage score (highest first)
-    eval_cards.sort(key=lambda x: x["coverage_score"], reverse=True)
-
-    html = ""
-    for eval_card in eval_cards:
-        html += format_eval_card_as_html(eval_card)
-
-    return html
-
-
-def upload_file(file):
-    """Process an uploaded YAML file"""
-    if file is None:
-        return "No file uploaded", None
+        return f"Error loading gallery: {str(e)}"
 
-    try:
-        yaml_content = file.decode("utf-8")
-        # Validate YAML
-        eval_data = yaml.safe_load(yaml_content)
-        return yaml_content, eval_data
-    except Exception as e:
-        return f"Error processing file: {str(e)}", None
 
+def get_llm_feedback(yaml_content):
+    """Get LLM feedback using Groq"""
+    api_token = os.environ.get("GROQ_API_KEY")
+    if not api_token:
+        return "Please set GROQ_API_KEY in Space settings to get LLM feedback."
 
-def get_feedback(yaml_content):
-    """Get LLM feedback on the eval card"""
-    if not yaml_content:
-        return "Please upload or paste a YAML file first."
+    if not yaml_content.strip():
+        return "Please provide YAML content first."
 
-    # Use provided token or get from environment
-    api_token = os.environ.get("GROQ_API_KEY")
+    try:
+        import requests
 
-    if not api_token:
-        return (
-            "Please provide an API token or set the GROQ_API_KEY environment variable."
+        response = requests.post(
+            "https://api.groq.com/openai/v1/chat/completions",
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {api_token}",
+            },
+            json={
+                "model": "llama-3.3-70b-versatile",
+                "messages": [
+                    {
+                        "role": "user",
+                        "content": f"Analyze this evaluation card YAML and provide specific improvement suggestions:\n\n```yaml\n{yaml_content}\n```\n\nFocus on completeness, clarity, and best practices.",
+                    }
+                ],
+            },
         )
 
-    feedback = get_llm_feedback(yaml_content, api_token)
-    return feedback
+        if response.status_code == 200:
+            return response.json()["choices"][0]["message"]["content"]
+        else:
+            return f"API Error {response.status_code}: {response.text}"
+
+    except Exception as e:
+        return f"Error getting feedback: {str(e)}"
 
 
-def submit_eval_card(yaml_content, paper_url="", repo_url=""):
-    """Submit an eval card to the repository"""
-    if not yaml_content:
-        return "Please upload or paste a YAML file first.", None, None
+# Simple functions for the interface
+def submit_card(yaml_text, paper_url, repo_url):
+    if not yaml_text.strip():
+        return "Please provide YAML content", ""
 
     try:
-        # Validate YAML
-        eval_data = yaml.safe_load(yaml_content)
+        yaml.safe_load(yaml_text)  # Validate YAML
+        result = save_eval_card(yaml_text, paper_url, repo_url)
+        gallery = load_gallery()
+        return result, gallery
+    except yaml.YAMLError as e:
+        return f"Invalid YAML: {str(e)}", ""
+    except Exception as e:
+        return f"Error: {str(e)}", ""
 
-        # Compute coverage score
-        score, score_details = compute_coverage_score(eval_data)
 
-        # Save eval card with URLs
-        result, file_path = save_eval_card(yaml_content, paper_url, repo_url)
+def load_template_text():
+    return get_template()
 
-        if file_path:
-            return (
-                f"Evaluation card saved successfully! Coverage score: {score}%",
-                score,
-                score_details,
-            )
-        else:
-            return f"Error saving evaluation card: {result}", None, None
 
-    except Exception as e:
-        return f"Error processing evaluation card: {str(e)}", None, None
+def get_feedback(yaml_text):
+    return get_llm_feedback(yaml_text)
 
 
 def refresh_gallery():
-    """Refresh the gallery of eval cards"""
-    eval_cards = load_all_eval_cards()
-    html = create_eval_cards_table(eval_cards)
-
-    # Convert data to pandas DataFrame for table view
-    table_data = []
-
-    # First, count authors across all cards
-    author_counts = {}
-    for card in eval_cards:
-        authors = card["authors"].split(", ")
-        for author in authors:
-            if author and author.strip():  # Skip empty authors
-                if author in author_counts:
-                    author_counts[author] += 1
-                else:
-                    author_counts[author] = 1
-
-    # Get top authors
-    top_authors = sorted(author_counts.items(), key=lambda x: x[1], reverse=True)[:20]
-    top_authors = [author for author, count in top_authors]
-
-    # Create table data with one entry per card
-    for card in eval_cards:
-        authors = card["authors"].split(", ")
-        filtered_authors = [author for author in authors if author in top_authors]
-        table_data.append(
-            {
-                "Title": card["title"],
-                "Authors": ", ".join(filtered_authors),
-                "Creation Date": card["creation_date"],
-                "Coverage Score": f"{card['coverage_score']}%",
-            }
-        )
+    return load_gallery()
+
+
+# Create the interface using older, more stable Gradio approach
+with gr.Blocks(
+    title="Evaluation Cards Gallery",
+    theme=gr.themes.Soft(),
+    css="footer {visibility: hidden}",
+) as demo:
+    gr.Markdown("""
+    # 📊 Evaluation Cards for Machine Learning
+    
+    Upload your evaluation card in YAML format and submit it to the persistent gallery.
+    Data is stored in HF dataset: [jablonkagroup/eval-cards-dataset](https://huggingface.co/datasets/jablonkagroup/eval-cards-dataset)
+    """)
 
-    df = pd.DataFrame(table_data)
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### ✏️ Create/Edit Evaluation Card")
+
+            yaml_editor = gr.Textbox(
+                label="YAML Content",
+                lines=15,
+                placeholder="Paste your YAML content or click 'Load Template'...",
+                value="",
+            )
 
-    return html, df if not df.empty else None
+            with gr.Row():
+                template_btn = gr.Button("📝 Load Template", size="sm")
+                feedback_btn = gr.Button("🤖 Get AI Feedback", size="sm")
 
+            paper_url = gr.Textbox(
+                label="📄 Paper URL (Optional)",
+                placeholder="https://arxiv.org/abs/...",
+                value="",
+            )
 
-def handle_upload_tab(file_obj, yaml_text):
-    """Handle upload tab actions - either use uploaded file or pasted text"""
-    if file_obj is not None:
-        yaml_content, eval_data = upload_file(file_obj)
-        return yaml_content
-    else:
-        return yaml_text
+            repo_url = gr.Textbox(
+                label="💻 Repository URL (Optional)",
+                placeholder="https://github.com/...",
+                value="",
+            )
 
+            submit_btn = gr.Button("🚀 Submit to Gallery", variant="primary", size="lg")
 
-# Create the Gradio interface
-with gr.Blocks(title="Evaluation Cards Gallery") as app:
-    with gr.Row():
-        with gr.Column(scale=2):
-            gr.Markdown(
-                "# Evaluation Cards for Machine Learning in Materials Science.  "
+            result_box = gr.Textbox(
+                label="📤 Submission Result", lines=3, interactive=False
             )
-            gr.Markdown("""         
-            Upload your evaluation card in YAML format, get feedback from an LLM, and submit it to the gallery.
-            checkout the [GitHub repository](https://github.com/lamalab-org/eval-cards) for more information.
-            """)
 
-    with gr.Tabs():
-        with gr.TabItem("Upload & Review"):
-            with gr.Row():
-                with gr.Column():
-                    file_upload = gr.File(
-                        label="Upload YAML File", file_types=[".yaml", ".yml"]
-                    )
-
-                    with gr.Accordion("Or paste YAML content", open=False):
-                        yaml_input = gr.TextArea(
-                            label="YAML Content",
-                            placeholder="Paste your YAML content here...",
-                            lines=10,
-                        )
-                    paper_url_input = gr.Textbox(
-                        label="Paper URL (Optional)",
-                        placeholder="https://arxiv.org/abs/...",
-                    )
-
-                    repo_url_input = gr.Textbox(
-                        label="Repository URL (Optional)",
-                        placeholder="https://github.com/...",
-                    )
-
-                    load_template_btn = gr.Button("Load Template")
-
-                    # api_token = gr.Textbox(label="API Token (for LLM feedback)", type="password")
-
-                    with gr.Row():
-                        get_feedback_btn = gr.Button("Get LLM Feedback")
-                        submit_btn = gr.Button(
-                            "Submit Evaluation Card", variant="primary"
-                        )
-
-                with gr.Column():
-                    yaml_display = gr.TextArea(label="Current YAML", lines=20)
-
-                    with gr.Accordion("LLM Feedback", open=True):
-                        feedback_display = gr.Markdown()
-
-                    with gr.Accordion("Submission Result", open=True):
-                        result_display = gr.Markdown()
-                        coverage_score = gr.Number(
-                            label="Coverage Score", visible=False
-                        )
-                        coverage_details = gr.JSON(
-                            label="Coverage Details", visible=False
-                        )
-
-        with gr.TabItem("Gallery"):
-            refresh_btn = gr.Button("Refresh Gallery")
-
-            with gr.Tabs():
-                with gr.TabItem("Card View"):
-                    gallery_html = gr.HTML()
-
-                with gr.TabItem("Table View"):
-                    gallery_table = gr.DataFrame()
-
-    # Set up event handlers
-    load_template_btn.click(fn=load_template, outputs=[yaml_display])
-
-    file_upload.change(
-        fn=handle_upload_tab, inputs=[file_upload, yaml_input], outputs=[yaml_display]
-    )
+        with gr.Column(scale=1):
+            gr.Markdown("### 🎯 AI Feedback")
+
+            feedback_box = gr.Textbox(
+                label="💡 Improvement Suggestions", lines=8, interactive=False
+            )
 
-    yaml_input.change(fn=lambda x: x, inputs=[yaml_input], outputs=[yaml_display])
+            gr.Markdown("### 🏛️ Gallery")
 
-    get_feedback_btn.click(
-        fn=get_feedback, inputs=[yaml_display], outputs=[feedback_display]
-    )
+            refresh_btn = gr.Button("🔄 Refresh Gallery", size="sm")
+
+            gallery_display = gr.HTML(value=load_gallery())
 
+    # Event handlers
+    template_btn.click(load_template_text, outputs=[yaml_editor])
+    feedback_btn.click(get_feedback, inputs=[yaml_editor], outputs=[feedback_box])
     submit_btn.click(
-        fn=submit_eval_card,
-        inputs=[yaml_display, paper_url_input, repo_url_input],
-        outputs=[result_display, coverage_score, coverage_details],
+        submit_card,
+        inputs=[yaml_editor, paper_url, repo_url],
+        outputs=[result_box, gallery_display],
     )
+    refresh_btn.click(refresh_gallery, outputs=[gallery_display])
 
-    refresh_btn.click(fn=refresh_gallery, outputs=[gallery_html, gallery_table])
-
-    # Initialize the gallery on app start
-    app.load(fn=refresh_gallery, outputs=[gallery_html, gallery_table])
-
-# Launch the app
 if __name__ == "__main__":
-    app.launch()
+    demo.launch()

requirements.txt

@@ -1,5 +1,5 @@
-gradio==4.36.0
-pyyaml>=6.0
-pandas>=2.0.0
-requests>=2.31.0
-python-dotenv>=1.0.0
+gradio
+pyyaml
+datasets
+huggingface_hub
+requests