🚧 'Frontend development

DEPLOYMENT.md

@@ -0,0 +1,92 @@
+# HuggingFace Spaces Deployment Guide
+
+## Prerequisites
+- ✅ HuggingFace account (`Tschoui`)
+- ✅ Private datasets created:
+  - `Tschoui/tox21-requests` 
+  - `Tschoui/tox21-results`
+- ✅ HuggingFace token with access to both datasets
+
+## Step 1: Create the Space
+
+1. **Go to**: https://huggingface.co/new-space
+2. **Fill in**:
+   - **Space name**: `tox21-leaderboard`
+   - **License**: Apache 2.0
+   - **SDK**: Gradio
+   - **Hardware**: CPU basic (free)
+   - **Visibility**: Public (users can see the leaderboard)
+3. **Click "Create Space"**
+
+## Step 2: Upload Your Code
+
+### Option A: Git (Recommended)
+```bash
+git clone https://huggingface.co/spaces/Tschoui/tox21-leaderboard
+cd tox21-leaderboard
+# Copy your files (excluding .env, .git, etc.)
+git add .
+git commit -m "Initial leaderboard setup"
+git push
+```
+
+### Option B: Web Upload
+1. **Go to your Space**: `https://huggingface.co/spaces/Tschoui/tox21-leaderboard`
+2. **Files and versions** tab
+3. **Upload files** - upload everything EXCEPT `.env`
+
+## Step 3: Configure Space Secrets
+
+1. **Go to your Space settings**: `https://huggingface.co/spaces/Tschoui/tox21-leaderboard/settings`
+2. **Repository secrets** section
+3. **New secret**:
+   - **Name**: `HF_TOKEN`
+   - **Value**: Your HuggingFace token (the same one from `.env`)
+4. **Save**
+
+## Step 4: Update README.md
+
+The Space needs proper metadata in `README.md`:
+
+```yaml
+---
+title: Tox21 Leaderboard  
+emoji: 🧪
+colorFrom: green
+colorTo: blue
+sdk: gradio
+app_file: app.py
+pinned: false
+license: apache-2.0
+---
+
+# Tox21 Leaderboard
+
+Molecular toxicity prediction leaderboard for the Tox21 dataset.
+```
+
+## Step 5: Deploy & Test
+
+1. **Push/Upload** your code
+2. **Space will build automatically**
+3. **Check logs** for any errors
+4. **Test** that it can connect to your datasets
+
+## Environment Handling
+
+### Local Development:
+- Uses `.env` file with your token
+- `load_dotenv()` loads the token
+
+### HuggingFace Spaces:
+- Uses Spaces Secrets (`HF_TOKEN`)
+- `.env` file not deployed (in `.gitignore`)
+- `os.environ.get("HF_TOKEN")` gets token from Spaces
+
+## Security Notes
+
+✅ **Safe**: Token stored in Spaces Secrets (encrypted)  
+✅ **Safe**: `.env` never pushed to git  
+✅ **Safe**: Users never see your token  
+❌ **Don't**: Hardcode tokens in source code  
+❌ **Don't**: Make datasets public if you don't want users seeing raw data

app.py

@@ -1,3 +1,11 @@
-import gradio as gr
-from gradio_leaderboard import Leaderboard, ColumnFilter, SelectColumns
-import pandas as pd
+from frontend.layout import create_main_interface
+from frontend.leaderboard import refresh_leaderboard
+
+# Create the main interface with callbacks
+demo, leaderboard_table = create_main_interface(
+    refresh_callback=refresh_leaderboard
+)
+
+if __name__ == "__main__":
+    demo.launch(
+    )

assets/examples/test_example_request.json

@@ -0,0 +1,9 @@
+{
+  "model": "example-org/example-model",
+  "revision": "main",
+  "precision": "float16",
+  "status": "PENDING",
+  "submitted_time": "2024-01-01T12:00:00Z",
+  "model_type": "pretrained",
+  "private": false
+}

assets/examples/test_example_result.json

@@ -0,0 +1,2 @@
+{"config": {"model_name": "toy model 1", "hf_space": "user/space_name", "model_description": "this is a toy model", "publication_title": "mhnfs", "publication_url": "https://openreview.net/pdf?id=XrMWUuEevr", "parameters": 0.1, "date_added": "2025-08-28", "model_revision": "v 1.0"}, "results": {"overall_score": {"roc_auc": 0.847}, "NR-AR": {"roc_auc": 0.85}, "NR-AR-LBD": {"roc_auc": 0.78}, "NR-AhR": {"roc_auc": 0.82}, "NR-Aromatase": {"roc_auc": 0.75}, "NR-ER": {"roc_auc": 0.88}, "NR-ER-LBD": {"roc_auc": 0.79}, "NR-PPAR-gamma": {"roc_auc": 0.81}, "SR-ARE": {"roc_auc": 0.76}, "SR-ATAD5": {"roc_auc": 0.83}, "SR-HSE": {"roc_auc": 0.77}, "SR-MMP": {"roc_auc": 0.8}, "SR-p53": {"roc_auc": 0.84}}}
+{"config": {"model_name": "toy model 2", "hf_space": "user/space_name2", "model_description": "this is another toy model with different scores", "publication_title": "Another Paper", "publication_url": "https://arxiv.org/abs/2301.00000", "parameters": 0.5, "date_added": "2025-08-28", "model_revision": "v 2.0"}, "results": {"overall_score": {"roc_auc": 0.792}, "NR-AR": {"roc_auc": 0.82}, "NR-AR-LBD": {"roc_auc": 0.75}, "NR-AhR": {"roc_auc": 0.79}, "NR-Aromatase": {"roc_auc": 0.72}, "NR-ER": {"roc_auc": 0.85}, "NR-ER-LBD": {"roc_auc": 0.76}, "NR-PPAR-gamma": {"roc_auc": 0.78}, "SR-ARE": {"roc_auc": 0.73}, "SR-ATAD5": {"roc_auc": 0.80}, "SR-HSE": {"roc_auc": 0.74}, "SR-MMP": {"roc_auc": 0.77}, "SR-p53": {"roc_auc": 0.81}}}

backend/data_loader.py

@@ -0,0 +1,57 @@
+"""
+Data loading functionality for the Tox21 leaderboard.
+Handles loading and processing results from HuggingFace datasets.
+"""
+
+import pandas as pd
+from datasets import load_dataset
+from config.settings import RESULTS_DATASET, HF_TOKEN
+
+
+def load_leaderboard_data() -> pd.DataFrame:
+    """
+    Load leaderboard data from HuggingFace dataset.
+    """
+    print(f"Loading dataset: {RESULTS_DATASET}")
+    
+    # Load the dataset
+    dataset = load_dataset(RESULTS_DATASET, token=HF_TOKEN)
+    print(f"Dataset loaded successfully. Keys: {dataset.keys()}")
+    
+    # Look for test split (more appropriate for results)
+    if 'test' in dataset:
+        results_data = dataset['test']
+        print(f"Test split has {len(results_data)} entries")
+        if len(results_data) > 0:
+            print(f"First entry keys: {results_data[0].keys()}")
+            print(f"First entry: {results_data[0]}")
+    else:
+        raise ValueError("Dataset does not contain a 'test' split.")
+    
+    # Convert to DataFrame
+    rows = []
+    for entry in results_data:
+        config = entry['config']
+        results = entry['results']
+        
+        # Create a row with all the data
+        row = {
+            'Model': config['model_name'],
+            'Model Description': config['model_description'],
+            'Publication': config['publication_title'],
+            'Parameters': config['parameters'],
+            'Date Added': str(config['date_added']).split()[0],  # Just the date part
+            'Overall Score': results['overall_score']['roc_auc']
+        }
+        
+        # Add individual task scores
+        for task_key, task_result in results.items():
+            if task_key != 'overall_score':  # Skip overall score
+                row[task_key] = task_result['roc_auc']
+        
+        rows.append(row)
+    
+    df = pd.DataFrame(rows)
+    print(df)
+    print(f"Created DataFrame with shape: {df.shape}")
+    return df

config/settings.py

@@ -0,0 +1,42 @@
+import os
+from dotenv import load_dotenv
+
+# Load environment variables from .env file (local development only)
+# On HuggingFace Spaces, environment variables come from Secrets
+try:
+    load_dotenv()  # This will be ignored if .env doesn't exist (on server)
+except:
+    pass
+
+# HuggingFace Configuration
+HUGGINGFACE_ORG = "Tschoui"  # Your HuggingFace username/org
+HF_TOKEN = os.environ.get("HF_TOKEN")  # Local: from .env, Server: from Spaces Secrets
+
+# Validate token exists
+if not HF_TOKEN:
+    print("⚠️  Warning: HF_TOKEN not found. Please set it in .env (local) or Spaces Secrets (server)")
+else:
+    print("✅ HF_TOKEN loaded successfully")
+
+# Dataset Repositories
+REQUESTS_DATASET = f"{HUGGINGFACE_ORG}/tox21-requests"
+RESULTS_DATASET = f"{HUGGINGFACE_ORG}/tox21-results"
+
+# Local Cache Paths
+CACHE_PATH = os.getenv("HF_HOME", ".")
+EVAL_REQUESTS_PATH = os.path.join(CACHE_PATH, "eval-queue")
+EVAL_RESULTS_PATH = os.path.join(CACHE_PATH, "eval-results")
+
+# Application Settings
+APP_TITLE = "Tox21 Leaderboard"
+APP_DESCRIPTION = "Leaderboard for molecular toxicity prediction on the Tox21 dataset"
+
+# Evaluation Settings
+DEFAULT_METRIC = "roc_auc"
+SUBMISSION_RATE_LIMIT = 5  # Max submissions per day per user
+EVALUATION_TIMEOUT = 3600  # 1 hour timeout for evaluations
+
+# Display Settings
+MAX_MODELS_DISPLAYED = 100
+DEFAULT_SORT_BY = "average_score"
+SHOW_PENDING_EVALUATIONS = True

config/tasks.py

@@ -0,0 +1,54 @@
+from dataclasses import dataclass
+from typing import List, Dict
+
+@dataclass
+class Task:
+    key: str
+    metric: str
+    display_name: str
+    description: str
+    group: str
+
+# Tox21 Task Definitions
+TOX21_TASKS = [
+    # Nuclear Receptors
+    Task("NR-AR", "roc_auc", "NR-AR", "Androgen receptor", "Nuclear Receptors"),
+    Task("NR-AR-LBD", "roc_auc", "NR-AR-LBD", "Androgen receptor ligand binding domain", "Nuclear Receptors"),
+    Task("NR-AhR", "roc_auc", "NR-AhR", "Aryl hydrocarbon receptor", "Nuclear Receptors"),
+    Task("NR-Aromatase", "roc_auc", "NR-Aromatase", "Aromatase enzyme", "Nuclear Receptors"),
+    Task("NR-ER", "roc_auc", "NR-ER", "Estrogen receptor", "Nuclear Receptors"),
+    Task("NR-ER-LBD", "roc_auc", "NR-ER-LBD", "Estrogen receptor ligand binding domain", "Nuclear Receptors"),
+    Task("NR-PPAR-gamma", "roc_auc", "NR-PPAR-gamma", "Peroxisome proliferator-activated receptor gamma", "Nuclear Receptors"),
+    
+    # Stress Response Pathways
+    Task("SR-ARE", "roc_auc", "SR-ARE", "Antioxidant response element", "Stress Response"),
+    Task("SR-ATAD5", "roc_auc", "SR-ATAD5", "ATPase family AAA domain-containing protein 5", "Stress Response"),
+    Task("SR-HSE", "roc_auc", "SR-HSE", "Heat shock element", "Stress Response"),
+    Task("SR-MMP", "roc_auc", "SR-MMP", "Mitochondrial membrane potential", "Stress Response"),
+    Task("SR-p53", "roc_auc", "SR-p53", "Tumor protein p53", "Stress Response"),
+]
+
+# Helper functions
+def get_task_by_key(key: str) -> Task:
+    """Get task by its key identifier"""
+    for task in TOX21_TASKS:
+        if task.key == key:
+            return task
+    raise ValueError(f"Task {key} not found")
+
+def get_tasks_by_group(group: str) -> List[Task]:
+    """Get all tasks in a specific group"""
+    return [task for task in TOX21_TASKS if task.group == group]
+
+def get_all_task_keys() -> List[str]:
+    """Get list of all task keys"""
+    return [task.key for task in TOX21_TASKS]
+
+def get_task_groups() -> Dict[str, List[Task]]:
+    """Get tasks organized by group"""
+    groups = {}
+    for task in TOX21_TASKS:
+        if task.group not in groups:
+            groups[task.group] = []
+        groups[task.group].append(task)
+    return groups

flagged/log.csv

@@ -0,0 +1,2 @@
+x,output,flag,username,timestamp
+test,Hello test!,,,2025-08-28 11:12:56.146286

frontend/content.py

@@ -0,0 +1,85 @@
+"""
+Content management for the Tox21 leaderboard frontend.
+Contains all text, styling, and data formatting - separated from UI layout.
+"""
+import pandas as pd
+from typing import Dict, List
+from config.tasks import TOX21_TASKS, get_task_groups
+from config.settings import APP_TITLE, APP_DESCRIPTION
+
+
+class LeaderboardContent:
+    """Content for the leaderboard tab"""
+    
+    title = "🧪 Tox21 Molecular Toxicity Leaderboard"
+    subtitle = "Ranking models by their performance on 12 toxicity prediction tasks"
+
+    
+    @staticmethod
+    def get_header_html() -> str:
+        """Generate header HTML"""
+        return f"""
+        <div class="header-section">
+            <h2 class="header-title">{LeaderboardContent.title}</h2>
+            <p class="header-subtitle">
+                {LeaderboardContent.subtitle}
+            </p>
+        </div>
+        """
+    
+    @staticmethod
+    def get_info_html() -> str:
+        """Generate info section HTML"""
+        return """
+        <div class="info-section">
+            <h4>ℹ️ How to Read the Leaderboard</h4>
+            <ul>
+                <li><strong>Average Score</strong>: Mean ROC-AUC across all 12 tasks</li>
+                <li><strong>Individual Tasks</strong>: ROC-AUC score (0.0 to 1.0, higher is better)</li>
+                <li><strong>Ranking</strong>: Models sorted by average score</li>
+            </ul>
+        </div>
+        """
+    
+
+
+class AboutContent:
+    """Content for the about tab"""
+    
+    @staticmethod
+    def get_markdown_content() -> str:
+        """Generate about page markdown content"""
+        return f"""
+        # About the Tox21 Leaderboard
+        
+        {APP_DESCRIPTION}
+        
+        # TODO
+        add more text. Assumption: If content gets more, this tab will be displayed 
+        more nicely.
+        
+        ## Citation
+        
+        If you use this leaderboard in your research, please cite:
+        
+        ```bibtex
+        -
+        ```
+        """
+
+
+class SubmissionContent:
+    """Content for the submission tab"""
+    
+    title = "🚀 Submit Your Model"
+    
+    @staticmethod
+    def get_instructions_html() -> str:
+        """Generate submission instructions HTML"""
+        return f"""
+        # TODO
+        add more text. Assumption: If content gets more, this tab will be displayed 
+        more nicely.
+        """
+
+

frontend/layout.py

@@ -0,0 +1,137 @@
+"""
+UI Layout components for the Tox21 leaderboard.
+Pure Gradio structure - no content or business logic.
+"""
+import gradio as gr
+from typing import Callable, Any
+from .content import LeaderboardContent, AboutContent, SubmissionContent
+from frontend.leaderboard import refresh_leaderboard
+import os
+import pandas as pd
+from gradio_leaderboard import Leaderboard
+
+
+def create_leaderboard_tab(refresh_callback: Callable = None) -> gr.TabItem:
+    """Create the leaderboard tab layout"""
+    
+    with gr.TabItem("🏅 Leaderboard", elem_id="leaderboard-tab", id=0) as tab:
+        
+        # Header section
+        header_html = gr.HTML(LeaderboardContent.get_header_html())
+        
+        # Load initial data
+        result_data = refresh_leaderboard().reset_index(drop=True)
+        result_data.columns = result_data.columns.map(str)
+
+        leaderboard_table = Leaderboard(
+            value=result_data,
+            search_columns=["Model", "Model Description", "Publication"],        # or e.g. ["Model", "Model Description", "Publication"]
+            select_columns=[],        # or e.g. ["Publication"]
+            filter_columns=[],        # or a list of valid column names/filters
+            hide_columns=[],          # keep explicit to be safe
+            elem_id="leaderboard-table",
+            height=480,       # only controls vertical
+            min_width=160,    # doesn’t prevent horizontal scroll
+            wrap=True,
+            column_widths=[200, 300, 150, 100, 120, 100] + [80] * 12,
+        )
+
+                    
+        # Info section
+        info_html = gr.HTML(LeaderboardContent.get_info_html())
+
+    return tab, leaderboard_table
+
+
+def create_about_tab() -> gr.TabItem:
+    """Create the about tab layout"""
+    
+    with gr.TabItem("📝 About", elem_id="about-tab", id=1) as tab:
+        content_markdown = gr.Markdown(
+            AboutContent.get_markdown_content(),
+            elem_classes="markdown-text"
+        )
+    
+    return tab
+
+
+def create_submission_tab(submit_callback: Callable = None) -> gr.TabItem:
+    """Create the submission tab layout"""
+    
+    with gr.TabItem("🚀 Submit", elem_id="submission-tab", id=2) as tab:
+        
+        # Header
+        gr.HTML(f"<h2 style='text-align: center;'>{SubmissionContent.title}</h2>")
+        
+        # Instructions
+        instructions_html = gr.HTML(SubmissionContent.get_instructions_html())
+        
+        # Future form components (commented out for now)
+        """
+        with gr.Group():
+            model_name = gr.Textbox(
+                label=SubmissionContent.form_labels["model_name"],
+                placeholder=SubmissionContent.form_placeholders["model_name"]
+            )
+            
+            with gr.Row():
+                model_revision = gr.Textbox(
+                    label=SubmissionContent.form_labels["model_revision"],
+                    placeholder=SubmissionContent.form_placeholders["model_revision"],
+                    value="main"
+                )
+                model_type = gr.Dropdown(
+                    choices=SubmissionContent.model_types,
+                    label=SubmissionContent.form_labels["model_type"]
+                )
+                precision = gr.Dropdown(
+                    choices=SubmissionContent.precisions,
+                    label=SubmissionContent.form_labels["precision"],
+                    value="float16"
+                )
+            
+            description = gr.Textbox(
+                label=SubmissionContent.form_labels["description"],
+                placeholder=SubmissionContent.form_placeholders["description"],
+                lines=3
+            )
+            
+            submit_btn = gr.Button("Submit Model", variant="primary")
+            result_msg = gr.HTML()
+            
+            if submit_callback:
+                submit_btn.click(
+                    fn=submit_callback,
+                    inputs=[model_name, model_revision, model_type, precision, description],
+                    outputs=result_msg
+                )
+        """
+    
+    return tab
+
+
+def create_main_interface(
+    refresh_callback: Callable = None,
+    submit_callback: Callable = None
+) -> gr.Blocks:
+    """Create the main application interface"""
+    
+    # Load CSS from file
+    css_path = os.path.join(os.path.dirname(__file__), 'styles.css')
+    with open(css_path, 'r') as f:
+        css = f.read()
+    
+    with gr.Blocks(css=css, title="Tox21 Leaderboard") as app:
+        
+        # Main title
+        gr.HTML("<h1>🧪 Tox21 Leaderboard</h1>")
+        
+        # Tab container
+        with gr.Tabs(elem_classes="tab-nav") as tabs:
+            
+            # Create all tabs
+            leaderboard_tab, leaderboard_table = create_leaderboard_tab(refresh_callback)
+            about_tab = create_about_tab()
+            submission_tab = create_submission_tab(submit_callback)
+    
+    return app, leaderboard_table

frontend/leaderboard.py

@@ -0,0 +1,104 @@
+"""
+Leaderboard-specific business logic.
+Handles data processing, backend communication, and state management.
+"""
+import pandas as pd
+from typing import Optional
+
+from .content import LeaderboardContent
+
+
+def refresh_leaderboard() -> pd.DataFrame:
+    """
+    Refresh leaderboard data by fetching from backend.
+    Currently returns sample data - will connect to backend later.
+    """
+    print("= Refreshing leaderboard data...")
+    
+    # Load data from backend
+    from backend.data_loader import load_leaderboard_data
+    
+    results_data = load_leaderboard_data()
+    return results_data
+
+
+def format_leaderboard_data(raw_data: dict) -> pd.DataFrame:
+    """
+    Format raw leaderboard data for display.
+    
+    Args:
+        raw_data: Raw data from backend/datasets
+        
+    Returns:
+        Formatted DataFrame for Gradio display
+    """
+    # TODO: Implement data formatting logic
+    # This will process raw evaluation results into the display format
+    pass
+
+
+def calculate_average_score(task_scores: dict) -> float:
+    """
+    Calculate average ROC-AUC score across all tasks.
+    
+    Args:
+        task_scores: Dictionary of task_name -> score
+        
+    Returns:
+        Average score across all tasks
+    """
+    if not task_scores:
+        return 0.0
+    
+    valid_scores = [score for score in task_scores.values() if score is not None]
+    if not valid_scores:
+        return 0.0
+    
+    return sum(valid_scores) / len(valid_scores)
+
+
+def sort_by_performance(leaderboard_data: pd.DataFrame) -> pd.DataFrame:
+    """
+    Sort leaderboard by average performance score.
+    
+    Args:
+        leaderboard_data: DataFrame with leaderboard data
+        
+    Returns:
+        Sorted DataFrame with rank column updated
+    """
+    # Sort by average score (descending)
+    sorted_data = leaderboard_data.sort_values(by="Average", ascending=False)
+    
+    # Update rank column
+    sorted_data["Rank"] = range(1, len(sorted_data) + 1)
+    
+    return sorted_data
+
+
+def filter_leaderboard(
+    data: pd.DataFrame, 
+    min_score: Optional[float] = None,
+    model_type: Optional[str] = None,
+    date_range: Optional[tuple] = None
+) -> pd.DataFrame:
+    """
+    Filter leaderboard data based on criteria.
+    
+    Args:
+        data: Original leaderboard data
+        min_score: Minimum average score threshold
+        model_type: Filter by model type
+        date_range: Filter by submission date range
+        
+    Returns:
+        Filtered DataFrame
+    """
+    filtered_data = data.copy()
+    
+    if min_score is not None:
+        filtered_data = filtered_data[filtered_data["Average"] >= min_score]
+    
+    # TODO: Add more filtering logic as needed
+    
+    return filtered_data

tests/test_dataset_connection.py

@@ -0,0 +1,84 @@
+from huggingface_hub import hf_hub_download, list_repo_files
+import json
+import sys
+import os
+
+# Add parent directory to path to import config
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from config.settings import REQUESTS_DATASET, RESULTS_DATASET, HF_TOKEN
+
+
+def test_dataset_connection():
+    """Test connection to both datasets"""
+    print("Testing dataset connections...")
+    
+    try:
+        # Test requests dataset
+        request_files = list_repo_files(
+            repo_id=REQUESTS_DATASET,
+            repo_type="dataset",
+            token=HF_TOKEN
+        )
+        print(f"✅ Requests dataset connected: {REQUESTS_DATASET}")
+        print(f"   Files: {request_files}")
+    except Exception as e:
+        print(f"❌ Requests dataset error: {e}")
+    
+    try:
+        # Test results dataset  
+        result_files = list_repo_files(
+            repo_id=RESULTS_DATASET,
+            repo_type="dataset", 
+            token=HF_TOKEN
+        )
+        print(f"✅ Results dataset connected: {RESULTS_DATASET}")
+        print(f"   Files: {result_files}")
+    except Exception as e:
+        print(f"❌ Results dataset error: {e}")
+
+
+def test_file_downloads():
+    """Test downloading example files"""
+    print("\nTesting file downloads...")
+    
+    try:
+        # Download and load example request
+        file_path = hf_hub_download(
+            repo_id=REQUESTS_DATASET,
+            filename="example_request.json",
+            repo_type="dataset",
+            token=HF_TOKEN
+        )
+        
+        with open(file_path, 'r') as f:
+            request_data = json.load(f)
+        
+        print("✅ Example request loaded:")
+        print(json.dumps(request_data, indent=2))
+        
+    except Exception as e:
+        print(f"❌ Request file error: {e}")
+    
+    try:
+        # Download and load example result
+        file_path = hf_hub_download(
+            repo_id=RESULTS_DATASET,
+            filename="example_result.json",
+            repo_type="dataset",
+            token=HF_TOKEN
+        )
+        
+        with open(file_path, 'r') as f:
+            result_data = json.load(f)
+        
+        print("✅ Example result loaded:")
+        print(json.dumps(result_data, indent=2))
+        
+    except Exception as e:
+        print(f"❌ Result file error: {e}")
+
+
+if __name__ == "__main__":
+    test_dataset_connection()
+    test_file_downloads()