Clean up unused code, files, and assets

Removed unused Python code:
- svg_to_data_uri() from leaderboard_transformer.py
- create_svg_html() from ui_components.py
- format_llm_base_with_html() from ui_components.py

Consolidated duplicate code:
- Renamed get_company_from_model_name to get_company_from_model in leaderboard_transformer.py
- Removed duplicate COMPANY_LOGO_MAP and get_company_from_model from ui_components.py
- ui_components.py and visualizations.py now import from leaderboard_transformer.py

Removed unused files:
- submission.py (submission functionality not exposed in app)
- submission_utils.py (only used by submission.py)
- generate_mock_jsonl.py (development utility)
- tests/integration/test_submission.py (tests for removed submission code)

Removed unused config:
- CONTACT_DATASET and SUBMISSION_DATASET from config.py

Removed unused CSS:
- Submission page CSS section from content.py

Removed 35 unused asset files:
- Various legend SVGs (api-*, c-*, os-*, custom-*, standard-*, equivalent-*)
- Category icons (code-execution, data-analysis, etc.)
- Star SVGs (three-point, four-point, five-point)
- Old logo files (openhands-logo.svg, logo-alibaba.svg, logo-huggingface.svg)
- Unused ellipse colors and other SVGs

config.py

@@ -5,16 +5,10 @@ CONFIG_NAME = os.getenv("HF_CONFIG", "1.0.0-dev1") # This corresponds to 'config
 IS_INTERNAL = os.environ.get("IS_INTERNAL", "false").lower() == "true"
 
 # OpenHands Index datasets
-CONTACT_DATASET = f"OpenHands/openhands-index-contact-info"
-
 if IS_INTERNAL:
-    # datasets backing the internal leaderboard
-    SUBMISSION_DATASET = f"OpenHands/openhands-index-internal-submissions"
     RESULTS_DATASET = f"OpenHands/openhands-index-internal-results"
     LEADERBOARD_PATH = f"OpenHands/openhands-index-internal-leaderboard"
 else:
-    # datasets backing the public leaderboard
-    SUBMISSION_DATASET = f"OpenHands/openhands-index-submissions"
     RESULTS_DATASET = f"OpenHands/openhands-index-results"
     LEADERBOARD_PATH = f"OpenHands/openhands-index"
 

content.py

@@ -631,129 +631,7 @@ span.wrap[tabindex="0"][role="button"][data-editable="false"] {
     margin: 20px 0;
     max-width: 800px;
 }
-/*------ Submission Page CSS ------*/
-#submission-modal .modal-container,
-#success-modal .modal-container {
-    height: auto;
-    max-width: 600px;
-}
-
-#submission-modal-content,
-#success-modal .submission-modal-content { 
-    padding: 20px;
-    background-color: inherit;
-    border-radius: 8px;
-    text-align: center;
-}
-
-#submission-modal-content p,
-#success-modal .submission-modal-content p {
-    font-size: 16px;
-}
 
-#legal-modal-content {
-    padding: 30px;
-    background-color: inherit;
-    border-radius: 8px;
-    text-align: left;
-    font-size: 14px;
-}
-
-#legal-modal-content h2 {
-    text-align: center;
-}
-#legal-modal-content button {
-    width: fit-content;
-}
-.spinner-container {
-    display: flex;
-    flex-direction: column;
-    align-items: center;
-    justify-content: center;
-    padding: 30px;
-}
-    
-.spinner {
-    width: 50px;
-    height: 50px;
-    border: 5px solid #dee2e6;
-    border-top: 5px solid #007bff;
-    border-radius: 50%;
-    animation: spin 1s linear infinite;
-    margin-bottom: 20px;
-}
-    
-@keyframes spin {
-    0% { transform: rotate(0deg); }
-    100% { transform: rotate(360deg); }
-}
-    
-#submission-page-container {
-    max-width: 800px;
-    margin: 0 auto;
-}
-
-#submission-file-label {
-    padding: 10px;
-}
-
-#submission-button {
-    max-width: fit-content;
-    font-size: 14px;
-}
-
-.custom-form-group {
-    border: 1px solid #000 !important; 
-    border-radius: 4px !important;
-    padding: 24px !important;
-    overflow: visible !important;    
-}
-
-#openness-label-html,
-#agent-tooling-label-html,
-#agent-info-label-html,
-#submitter-info-label-html,
-#username-label-html,
-#email-label-html,
-#role-label-html  {
-    padding-left: 12px;
-}
-
-.form-label {
-    margin: 4px 0px 0px 6px;
-}
-
-.form-label-fieldset {
-    padding-top: 10px !important;
-}
-
-#agent-tooling-label-html {
-    padding-top: 6px;
-}
-
-.custom-form-group,
-.styler {
-    background: none;
-}
-
-#feedback-button {
-    display: inline-block;
-    background-color: var(--color-primary-link);
-    color: white;
-    border: none;
-    border-radius: 4px;
-    padding: 15px 20px;
-    font-size: 16px;
-    cursor: pointer;
-    transition: all 0.3s ease;
-    text-decoration: none;
-}
-
-#feedback-button:hover {
-    background-color: var(--color-button-hover);
-    transform: translateY(-2px);
-    box-shadow: 0 6px 12px rgba(0,0,0,0.3);
-}
 .dark #main-header h2 {
     color: var(--color-primary-accent); 
 }

generate_mock_jsonl.py

@@ -1,161 +0,0 @@
-"""Generate mock results data in JSONL format for OpenHands Index."""
-import json
-import os
-from pathlib import Path
-from datetime import datetime
-
-# Define the 5 benchmarks
-BENCHMARKS = {
-    "swe-bench": {
-        "tags": ["swe-bench"],
-        "metric": "resolve_rate",
-        "metric_display": "Resolve Rate (%)"
-    },
-    "swe-bench-multimodal": {
-        "tags": ["swe-bench-multimodal"],
-        "metric": "resolve_rate",
-        "metric_display": "Resolve Rate (%)"
-    },
-    "swt-bench": {
-        "tags": ["swt-bench"],
-        "metric": "success_rate",
-        "metric_display": "Success Rate (%)"
-    },
-    "commit0": {
-        "tags": ["commit0"],
-        "metric": "test_pass_rate",
-        "metric_display": "Test Pass Rate (%)"
-    },
-    "gaia": {
-        "tags": ["gaia"],
-        "metric": "accuracy",
-        "metric_display": "Accuracy (%)"
-    }
-}
-
-# Mock agents with realistic scores
-MOCK_AGENTS = [
-    {
-        "agent_name": "1.0.2",
-        "llm_base": "claude-3-5-sonnet-20241022",
-        "openness": "closed",
-        "scores": {
-            "swe-bench": 48.3,
-            "swe-bench-multimodal": 42.1,
-            "swt-bench": 65.4,
-            "commit0": 71.2,
-            "gaia": 58.7
-        }
-    },
-    {
-        "agent_name": "1.0.1",
-        "llm_base": "gpt-4o-2024-11-20",
-        "openness": "closed",
-        "scores": {
-            "swe-bench": 45.1,
-            "swe-bench-multimodal": 39.5,
-            "swt-bench": 62.3,
-            "commit0": 68.9,
-            "gaia": 55.2
-        }
-    },
-    {
-        "agent_name": "1.0.0",
-        "llm_base": "gpt-4-turbo-2024-04-09",
-        "openness": "closed",
-        "scores": {
-            "swe-bench": 38.7,
-            "swe-bench-multimodal": 34.2,
-            "swt-bench": 54.1,
-            "commit0": 61.5,
-            "gaia": 48.3
-        }
-    },
-    {
-        "agent_name": "0.9.5",
-        "llm_base": "gpt-4o-mini-2024-07-18",
-        "openness": "closed",
-        "scores": {
-            "swe-bench": 32.5,
-            "swe-bench-multimodal": 28.9,
-            "swt-bench": 47.8,
-            "commit0": 55.3,
-            "gaia": 42.1
-        }
-    },
-    {
-        "agent_name": "0.9.0",
-        "llm_base": "claude-3-opus-20240229",
-        "openness": "closed",
-        "scores": {
-            "swe-bench": 29.8,
-            "swe-bench-multimodal": 25.7,
-            "swt-bench": 44.2,
-            "commit0": 52.1,
-            "gaia": 39.4
-        }
-    },
-]
-
-
-def generate_mock_data():
-    """Generate mock JSONL files for all benchmarks."""
-    output_dir = Path("mock_results/1.0.0-dev1")
-    output_dir.mkdir(parents=True, exist_ok=True)
-    
-    # Create agenteval.json config
-    config = {
-        "suite_config": {
-            "name": "openhands-index",
-            "version": "1.0.0-dev1",
-            "splits": []
-        }
-    }
-    
-    # Generate data for each benchmark
-    for benchmark_name, benchmark_info in BENCHMARKS.items():
-        print(f"Generating mock data for {benchmark_name}...")
-        
-        # Add to config
-        config["suite_config"]["splits"].append({
-            "name": benchmark_name,
-            "tasks": [{
-                "name": benchmark_name,
-                "tags": benchmark_info["tags"]
-            }]
-        })
-        
-        # Generate JSONL file
-        jsonl_path = output_dir / f"{benchmark_name}.jsonl"
-        with open(jsonl_path, 'w') as f:
-            for agent in MOCK_AGENTS:
-                record = {
-                    "agent_name": agent["agent_name"],
-                    "llm_base": agent["llm_base"],
-                    "openness": agent["openness"],
-                    "score": agent["scores"][benchmark_name],
-                    "metric": benchmark_info["metric"],
-                    "submission_time": datetime.now().isoformat(),
-                    "tags": benchmark_info["tags"],
-                    # Additional metadata
-                    "cost_per_instance": round(0.1 + agent["scores"][benchmark_name] * 0.01, 4),
-                    "average_runtime": round(300 + agent["scores"][benchmark_name] * 5, 1),
-                }
-                f.write(json.dumps(record) + '\n')
-        
-        print(f"  Created {jsonl_path}")
-    
-    # Write config file
-    config_path = output_dir / "agenteval.json"
-    with open(config_path, 'w') as f:
-        json.dump(config, f, indent=2)
-    print(f"\nCreated config: {config_path}")
-    
-    print("\n✓ Mock data generation complete!")
-    print(f"  Location: {output_dir}")
-    print(f"  Benchmarks: {', '.join(BENCHMARKS.keys())}")
-    print(f"  Agents: {len(MOCK_AGENTS)}")
-
-
-if __name__ == "__main__":
-    generate_mock_data()

leaderboard_transformer.py

@@ -128,7 +128,7 @@ def add_branding_to_figure(fig: go.Figure) -> go.Figure:
     return fig
 
 
-def get_company_from_model_name(model_name: str) -> dict:
+def get_company_from_model(model_name: str) -> dict:
     """
     Gets the company info (logo path and name) from a model name.
     Returns default unknown logo if no match found.
@@ -696,7 +696,7 @@ def _plot_scatter_plotly(
     
     for _, row in data_plot.iterrows():
         model_name = row.get('Language Model', '')
-        company_info = get_company_from_model_name(model_name)
+        company_info = get_company_from_model(model_name)
         logo_path = company_info['path']
         
         # Read the SVG file and encode as base64 data URI
@@ -994,16 +994,6 @@ def get_pareto_df(data, cost_col=None, score_col=None):
     return pd.DataFrame(pareto_points)
 
 
-def svg_to_data_uri(path: str) -> str:
-    """Reads an SVG file and encodes it as a Data URI for Plotly."""
-    try:
-        with open(path, "rb") as f:
-            encoded_string = base64.b64encode(f.read()).decode()
-        return f"data:image/svg+xml;base64,{encoded_string}"
-    except FileNotFoundError:
-        logger.warning(f"SVG file not found at: {path}")
-        return None
-
 def clean_llm_base_list(model_list):
     """
     Cleans a list of model strings by keeping only the text after the last '/'.

submission.py

@@ -1,474 +0,0 @@
-import logging
-import typing
-
-import matplotlib
-matplotlib.use('Agg')
-
-import os
-import shutil
-import tarfile
-from datetime import datetime, timedelta, timezone
-from email.utils import parseaddr
-
-import gradio as gr
-import requests
-from huggingface_hub import HfApi
-
-import aliases
-from submission_utils import (
-    SUBMISSION_METADATA_FILENAME,
-    SubmissionMetadata,
-    sanitize_path_component,
-    _validate_path_component
-)
-from config import (
-    CONFIG_NAME,
-    CONTACT_DATASET,
-    EXTRACTED_DATA_DIR,
-    RESULTS_DATASET,
-    SUBMISSION_DATASET,
-)
-from content import (
-    CITATION_BUTTON_LABEL,
-    CITATION_BUTTON_TEXT,
-    LEGAL_DISCLAIMER_TEXT,
-    SUBMISSION_CONFIRMATION,
-    format_error,
-    format_log,
-    format_warning,
-)
-from ui_components import build_openness_tooltip_content, build_tooling_tooltip_content
-
-# Simple stubs for dataset functionality (not using HF datasets)
-class DatasetDict(dict):
-    """Simple stub for datasets.DatasetDict."""
-    pass
-
-class Dataset:
-    """Simple stub for datasets.Dataset."""
-    @staticmethod
-    def from_list(data):
-        return Dataset()
-    
-def load_dataset(*args, **kwargs):
-    """Simple stub for datasets.load_dataset."""
-    return DatasetDict()
-
-class EmptyDatasetError(Exception):
-    """Simple stub for datasets exception."""
-    pass
-
-class DataFilesNotFoundError(Exception):
-    """Simple stub for datasets exception."""
-    pass
-
-
-logger = logging.getLogger(__name__)
-logger.setLevel(logging.DEBUG)
-
-api = HfApi()
-MAX_UPLOAD_BYTES = 5e9
-os.makedirs(EXTRACTED_DATA_DIR, exist_ok=True)
-
-# --- Submission Logic (largely unchanged from original, ensure LeaderboardSubmission and other deps are fine) ---
-def try_load_dataset_submission(*args, **kwargs) -> DatasetDict: # Renamed to avoid conflict if LV has one
-    try:
-        return load_dataset(*args, **kwargs)
-    except EmptyDatasetError:
-        return DatasetDict()
-    except ValueError: # Handles cases where dataset is empty or ill-formed
-        return DatasetDict()
-    except DataFilesNotFoundError:
-        return DatasetDict()
-
-def upload_submission(
-        folder_path: str,
-        split: str,
-        submission_name: str,
-        hf_username: str,
-) -> str:
-    total = 0
-    for root, _, files in os.walk(folder_path):
-        for f_ul in files:
-            total += os.path.getsize(os.path.join(root, f_ul))
-            if total > MAX_UPLOAD_BYTES:
-                raise ValueError(
-                    f"Upload too large: exceeds {MAX_UPLOAD_BYTES // 1000000} MB limit."
-                )
-
-    # This is a copy of agenteval.upload.upload_folder_to_hf so we can use other api params.
-    # TODO in agenteval: When you mildly wrap another library call, always pass *args, **kwargs.
-    _validate_path_component(CONFIG_NAME, "config_name")
-    _validate_path_component(split, "split")
-    _validate_path_component(submission_name, "submission_name")
-    dataset_url = f"hf://datasets/{SUBMISSION_DATASET}/{CONFIG_NAME}/{split}/{submission_name}"
-    logger.info(f"Uploading dataset {dataset_url}")
-    api.upload_folder(
-        folder_path=folder_path,
-        path_in_repo=f"{CONFIG_NAME}/{split}/{submission_name}",
-        repo_id=SUBMISSION_DATASET,
-        repo_type="dataset",
-        # Reminder: This may be going into a public dataset.
-        # Don't put private information in commit message such as email.
-        commit_message=f'Submission from hf user "{hf_username}" to "{dataset_url}"',
-    )
-    return dataset_url
-
-def show_loading_spinner():
-    return gr.update(visible=True)
-
-def add_new_eval(
-        val_or_test: str,
-        agent_name: str | None,
-        agent_description: str,
-        agent_url: str,
-        openness: str | None,
-        degree_of_control: str | None,
-        path_to_file: typing.IO | None,
-        username: str,
-        role: str,
-        email: str,
-        email_opt_in: bool,
-        profile: gr.OAuthProfile,
-):
-    if not agent_name:
-        return (
-            format_warning("Please provide an agent name."),  # error_message
-            gr.update(visible=True),                            # error_modal
-            gr.update(visible=False),                           # success_modal
-            gr.update(visible=False)                            # loading_modal
-        )
-
-    if path_to_file is None:
-        return (
-            format_warning("Please attach a .tar.gz file."),  # error_message
-            gr.update(visible=True),                            # error_modal
-            gr.update(visible=False),                           # success_modal
-            gr.update(visible=False)                            # loading_modal
-        )
-
-    logger.info(f"agent {agent_name}: Checking submission")
-
-    # Load current eval_results for submission checks
-    # This is a bit redundant if display part reloads it, but submission needs its own consistent view
-    current_eval_results_for_submission = try_load_dataset_submission(
-        RESULTS_DATASET,
-        CONFIG_NAME,
-        download_mode="force_redownload", # Or a less aggressive mode
-        verification_mode=VerificationMode.NO_CHECKS,
-    )
-
-    submission_time = datetime.now(timezone.utc)
-    if not username or username.strip() == "":
-        username = profile.username # Default to HF username
-
-    logger.debug(f"agent {agent_name}: User account age check {profile.username}")
-    try:
-        # Account age check disabled for launch.
-        # https://github.com/allenai/astabench-issues/issues/419
-        # if _is_hf_acct_too_new(submission_time, profile.username):
-        #     return (
-        #         format_error("This account is not authorized to submit here (account too new)."),  # error_message
-        #         gr.update(visible=True),                            # error_modal
-        #         gr.update(visible=False),                           # success_modal
-        #         gr.update(visible=False)                            # loading_modal
-        #     )
-        pass
-    except Exception as e:
-        logger.warning(f"Error checking user account age: {e}")
-        return (
-            format_error("Could not verify account age. Please try again later."),  # error_message
-            gr.update(visible=True),                            # error_modal
-            gr.update(visible=False),                           # success_modal
-            gr.update(visible=False)                            # loading_modal
-        )
-
-    logger.debug(f"agent {agent_name}: Submission frequency check {profile.username}")
-    contact_infos = try_load_dataset_submission(
-        CONTACT_DATASET, CONFIG_NAME, download_mode="force_redownload",
-        verification_mode=VerificationMode.NO_CHECKS
-    )
-    if _is_last_submission_too_recent(
-        contact_rows=contact_infos.get(val_or_test, []),
-        username=profile.username,
-        submission_time=submission_time,
-    ):
-        logger.info(f"agent {agent_name}: Denied submission because user {username} submitted recently")
-        return (
-            format_error("You already submitted once in the last 24h for this split; please try again later."),  # error_message
-            gr.update(visible=True),                            # error_modal
-            gr.update(visible=False),                           # success_modal
-            gr.update(visible=False)                            # loading_modal
-        )
-
-    logger.debug(f"agent {agent_name}: Email validation {email}")
-    _, parsed_mail = parseaddr(email)
-    if "@" not in parsed_mail:
-        return (
-            format_warning("Please provide a valid email address."),  # error_message
-            gr.update(visible=True),                            # error_modal
-            gr.update(visible=False),                           # success_modal
-            gr.update(visible=False)                            # loading_modal
-        )
-
-    logger.debug(f"agent {agent_name}: Duplicate submission check")
-    if val_or_test in current_eval_results_for_submission and len(current_eval_results_for_submission[val_or_test]) > 0:
-        existing_submissions = current_eval_results_for_submission[val_or_test].to_dict().get("submission", [])
-        for sub_item in existing_submissions:
-            if (sub_item.get("agent_name", "").lower() == agent_name.lower() and
-                    sub_item.get("username", "").lower() == username.lower()):
-                return (
-                    format_warning("This agent name by this user has already been submitted to this split."),  # error_message
-                    gr.update(visible=True),                            # error_modal
-                    gr.update(visible=False),                           # success_modal
-                    gr.update(visible=False)                            # loading_modal
-                )
-
-    safe_username = sanitize_path_component(username)
-    safe_agent_name = sanitize_path_component(agent_name)
-    extracted_dir = os.path.join(EXTRACTED_DATA_DIR, f"{safe_username}_{safe_agent_name}")
-
-    logger.debug(f"agent {agent_name}: File extraction to {extracted_dir}")
-    try:
-        if os.path.exists(extracted_dir): shutil.rmtree(extracted_dir)
-        os.makedirs(extracted_dir, exist_ok=True)
-        with tarfile.open(path_to_file.name, "r:gz") as tar:
-            members_extracted = 0
-            for member in tar.getmembers():
-                if not member.isreg(): continue
-                fname = os.path.basename(member.name)
-                if not fname or fname.startswith("."): continue
-                fobj = tar.extractfile(member)
-                if not fobj: continue
-                with open(os.path.join(extracted_dir, fname), "wb") as out:
-                    out.write(fobj.read())
-                members_extracted +=1
-            if members_extracted == 0:
-                return (
-                    format_error("Submission tarball is empty or contains no valid files."),  # error_message
-                    gr.update(visible=True),                            # error_modal
-                    gr.update(visible=False),                           # success_modal
-                    gr.update(visible=False)                            # loading_modal
-                )
-    except Exception as e:
-        return (
-            format_error(f"Error extracting file: {e}. Ensure it's a valid .tar.gz."),  # error_message
-            gr.update(visible=True),                            # error_modal
-            gr.update(visible=False),                           # success_modal
-            gr.update(visible=False)                            # loading_modal
-        )
-
-    submission_name = f"{safe_username}_{safe_agent_name}_{submission_time.strftime('%Y-%m-%d_%H-%M-%S')}"
-
-    logger.debug(f"agent {agent_name}: Generate submission.json")
-    subm_meta = SubmissionMetadata(
-        agent_name=agent_name,
-        agent_description=agent_description,
-        agent_url=agent_url,
-        openness=openness,
-        tool_usage=degree_of_control,
-        username=username,
-        submit_time=submission_time,
-    )
-    with open(os.path.join(extracted_dir, SUBMISSION_METADATA_FILENAME), "w", encoding="utf-8") as fp:
-        fp.write(subm_meta.model_dump_json(indent=2))
-
-    logger.info(f"agent {agent_name}: Upload raw (unscored) submission files")
-    try:
-        dataset_url = upload_submission(extracted_dir, val_or_test, submission_name, profile.username)
-    except ValueError as e:
-        return (
-            format_error(str(e)),                               # error_message
-            gr.update(visible=True),                            # error_modal
-            gr.update(visible=False),                           # success_modal
-            gr.update(visible=False)                            # loading_modal
-        )
-    except Exception as e:
-        return (
-            format_error(f"Failed to upload raw submission: {e}"),  # error_message
-            gr.update(visible=True),                            # error_modal
-            gr.update(visible=False),                           # success_modal
-            gr.update(visible=False)                            # loading_modal
-        )
-
-    logger.info(f"agent {agent_name}: Save contact information")
-    contact_info = subm_meta.model_dump()
-    contact_info["username_auth"] = profile.username
-    contact_info["email"] = email
-    contact_info["email_opt_in"] = email_opt_in
-    contact_info["role"] = role
-    contact_info["dataset_url"] = dataset_url
-
-    logger.debug(f"agent {agent_name}: Contact info: {contact_info}")
-    if val_or_test in contact_infos:
-        contact_infos[val_or_test] = contact_infos[val_or_test].add_item(contact_info)
-    else:
-        contact_infos[val_or_test] = Dataset.from_list([contact_info])
-
-    try:
-        contact_infos.push_to_hub(
-            repo_id=CONTACT_DATASET,
-            config_name=CONFIG_NAME,
-            commit_message=f'Submission from hf user "{profile.username}" to "{dataset_url}"',
-        )
-    except Exception as e:
-        return (
-            format_error(f"Submission recorded, but contact info failed to save: {e}"),  # error_message
-            gr.update(visible=True),                            # error_modal
-            gr.update(visible=False),                           # success_modal
-            gr.update(visible=False)                            # loading_modal
-        )
-
-    logger.info(f"Agent '{agent_name}' submitted successfully by '{username}' to '{val_or_test}' split.")
-    return (
-        "",                                                 # message
-        gr.update(visible=False),                           # error_modal
-        gr.update(visible=True),                            # success_modal
-        gr.update(visible=False)                            # loading_modal
-    )
-
-
-def _is_hf_acct_too_new(submission_time: datetime, username: str):
-    user_data_resp = requests.get(f"https://huggingface.co/api/users/{username}/overview")
-    user_data_resp.raise_for_status()
-    creation_date_str = user_data_resp.json()["createdAt"]
-    created_at = datetime.strptime(creation_date_str, "%Y-%m-%dT%H:%M:%S.%fZ").replace(tzinfo=timezone.utc)
-    return submission_time - created_at < timedelta(days=60)
-
-
-def _is_last_submission_too_recent(contact_rows, username, submission_time):
-    user_submission_dates = sorted(
-        row["submit_time"] for row in contact_rows if row["username_auth"] == username
-    )
-    return user_submission_dates and (submission_time - user_submission_dates[-1] < timedelta(days=1))
-
-
-openness_label_html = f"""<div>
-    <b>Agent Openness</b>
-    {build_openness_tooltip_content()}
-</div>"""
-
-
-agent_tooling_label_html = f"""<div>
-    <b>Agent Tooling</b>
-    {build_tooling_tooltip_content()}
-</div>"""
-
-
-heading_html = """
-<h2>🚀 Submit an agent for evaluation</h2>
-<p>Submit your agent to OpenHands Index for evaluation on real-world scientific tasks. Once submitted, your run will be reviewed by our team. If there are any issues, we’ll reach out within 5–7 business days. We’re working toward full automation, but in the meantime, human review helps ensure quality and trust.</p>
-<h3>How to run an evaluation</h3>
-<p>Please follow the steps in our <a href="https://github.com/allenai/asta-bench?tab=readme-ov-file#usage" target="_blank">README</a>. You’ll upload your run file at the end of this form.</p>
-"""
-
-# --- Submission Accordion ---
-def build_page():
-    with gr.Column(elem_id="submission-page-container"):
-        gr.HTML(heading_html)
-        gr.LoginButton()
-        with gr.Group(elem_classes="custom-form-group"):
-            gr.HTML(value="""<h2>Submitter Information</h2>""", elem_id="submitter-info-label-html")
-            gr.HTML(value="""<h3>Username</h3>""", elem_classes="form-label")
-            username_tb = gr.Textbox(label="This will show on the leaderboard. By default, we’ll use your Hugging Face username; but you can enter your organization name instead (e.g., university, company, or lab).")
-            gr.HTML(value="""<h3>Role</h3>""", elem_classes="form-label")
-            role = gr.Dropdown(label="Please select the role that most closely matches your current position. Helps us improve OpenHands Index for different user types. Not displayed on the leaderboard.",
-                interactive=True,
-                choices=[
-                    "Undergraduate Student",
-                    "Masters Student",
-                    "PhD Student",
-                    "Postdoctoral Researcher",
-                    "Academic Faculty (e.g., Professor, Lecturer)",
-                    "Industry Researcher (e.g., Research Scientist, Applied Scientist)",
-                    "Engineer or Developer (e.g., Software or ML Engineer)",
-                    "Data Scientist or Analyst",
-                    "Product or Program Manager",
-                    "Startup Founder or Independent Researcher",
-                    "Other"
-            ])
-            gr.HTML(value="""<h3>Contact email</h3>""", elem_classes="form-label")
-            mail_tb = gr.Textbox(label="We'll only use your email to communicate about your submission.")
-            mail_opt_in = gr.Checkbox(label="I’m open to being contacted by email for user research studies or feedback opportunities.")
-        with gr.Group(elem_classes="custom-form-group"):
-            gr.HTML(value="""<h2>Agent Information</h2>""", elem_id="agent-info-label-html")
-            gr.HTML(value="""<h3>Split</h3>""", elem_classes="form-label")
-            level_of_test_radio = gr.Radio(choices=[
-                ("Test set", "test"),
-                ("Validation set", "validation"),
-            ], elem_classes="form-label-fieldset", value="validation", label="The Test Set is used for final leaderboard rankings. The Validation Set is for development and iteration. Choose based on your evaluation goal.")
-            gr.HTML(value="""<h3>Agent name</h3>""", elem_classes="form-label")
-            agent_name_tb = gr.Textbox(label="This is how your agent will appear on the leaderboard. Use a clear, descriptive name (e.g., Asta Scholar QA, Perplexity Deep Research). Omit model names (e.g. GPT-4, Mistral) as they’ll be shown automatically based on your logs.")
-            gr.HTML(value="""<h3>Agent description</h3>""", elem_classes="form-label")
-            agent_desc_tb = gr.Textbox(label="Briefly describe your agent’s approach, core strategies, or what makes it distinct. This description may appear on the leaderboard.")
-            gr.HTML(value="""<h3>URL</h3>""", elem_classes="form-label")
-            agent_url_tb = gr.Textbox(label="Link to more information about your agent (e.g. GitHub repo, blog post, or website). This optional link may be shown on the leaderboard to let others explore your agent in more depth.")
-            gr.HTML(value=openness_label_html, elem_classes="form-label")
-            openness_radio = gr.Radio([aliases.CANONICAL_OPENNESS_OPEN_SOURCE_CLOSED_WEIGHTS, aliases.CANONICAL_OPENNESS_OPEN_SOURCE_OPEN_WEIGHTS, aliases.CANONICAL_OPENNESS_CLOSED_API_AVAILABLE, aliases.CANONICAL_OPENNESS_CLOSED_UI_ONLY], elem_classes="form-label-fieldset", value=None, label="This affects how your submission is categorized on the leaderboard. Choose based on the availability of your code, model weights, or APIs.")
-            gr.HTML(value=agent_tooling_label_html, elem_classes="form-label")
-            degree_of_control_radio = gr.Radio([aliases.CANONICAL_TOOL_USAGE_STANDARD, aliases.CANONICAL_TOOL_USAGE_CUSTOM_INTERFACE, aliases.CANONICAL_TOOL_USAGE_FULLY_CUSTOM], elem_classes="form-label-fieldset",value=None, label="Choose based on the tools and the execution environment your agent used during evaluation.")
-            gr.HTML(value="""<h3>Submission file</h3>""", elem_classes="form-label")
-            gr.HTML("<div id='submission-file-label'>Upload your run as a .tar.gz archive prepared using the steps in the <a href='https://github.com/allenai/asta-bench?tab=readme-ov-file#submitting-to-the-leaderboard' target='_blank'>README</a> (“Submitting to the Leaderboard”).</div>")
-            file_upload_comp = gr.File(
-                show_label=False,
-                file_types=[".gz", ".tar.gz"],
-            )
-            submit_eval_button = gr.Button("Submit Evaluation", elem_id="submission-button")
-    # Modals for loading spinner, success and error messages
-    with Modal(visible=False, elem_id="submission-modal") as loading_modal:
-        with gr.Column(elem_id="submission-modal-content"):
-            gr.HTML('<div class="spinner-container"><div class="spinner"></div><p>Processing your submission...</p></div>')
-    
-    with Modal(visible=False, elem_id="submission-modal") as error_modal:
-        with gr.Column(elem_id="submission-modal-content"):
-            gr.Markdown("## ⚠️ Error")
-            error_message = gr.Markdown()
-
-    with Modal(visible=False, elem_id="success-modal") as success_modal:
-        with gr.Column(elem_id="submission-modal-content"):
-            gr.Markdown(SUBMISSION_CONFIRMATION)
-    with Modal(visible=False, elem_id="submission-modal") as disclaimer_modal:
-        with gr.Column(elem_id="legal-modal-content"):
-            gr.HTML(LEGAL_DISCLAIMER_TEXT)
-            with gr.Row():
-                agree_button = gr.Button("I agree to the terms and conditions above", variant="primary")
-
-    def accept_and_load():
-        return [
-            gr.update(visible=False), # Hide disclaimer_modal
-            gr.update(visible=True)   # Show loading_modal
-        ]
-
-    def show_disclaimer():
-        return gr.update(visible=True)
-
-    submit_eval_button.click(
-        fn=show_disclaimer,
-        inputs=None,
-        outputs=[disclaimer_modal]
-    )
-
-    agree_button.click(
-        fn=accept_and_load,
-        inputs=None,
-        outputs=[disclaimer_modal, loading_modal],
-    ).then(
-        fn=add_new_eval,
-        inputs=[
-            level_of_test_radio,
-            agent_name_tb,
-            agent_desc_tb,
-            agent_url_tb,
-            openness_radio,
-            degree_of_control_radio,
-            file_upload_comp,
-            username_tb,
-            role,
-            mail_tb,
-            mail_opt_in
-        ],
-        outputs=[error_message, error_modal, success_modal, loading_modal],
-    )
-    # hiding this for now till we have the real paper data
-    # with gr.Accordion("📙 Citation", open=False):
-    #     gr.Textbox(value=CITATION_BUTTON_TEXT, label=CITATION_BUTTON_LABEL, elem_id="citation-button-main", interactive=False)

submission_utils.py

@@ -1,88 +0,0 @@
-"""
-Utilities for submission handling, replacing agent-eval dependencies.
-"""
-import re
-from pathlib import Path
-from typing import Optional
-
-
-# Constants
-SUBMISSION_METADATA_FILENAME = "metadata.json"
-
-
-# Simple SubmissionMetadata class
-class SubmissionMetadata:
-    """Simple metadata for submissions."""
-    def __init__(self, **kwargs):
-        self.agent_name = kwargs.get("agent_name", "")
-        self.llm_base = kwargs.get("llm_base", "")
-        self.openness = kwargs.get("openness", "")
-        self.tool_usage = kwargs.get("tool_usage", "")
-        self.submitter_name = kwargs.get("submitter_name", "")
-        self.submitter_email = kwargs.get("submitter_email", "")
-        
-    def to_dict(self):
-        return {
-            "agent_name": self.agent_name,
-            "llm_base": self.llm_base,
-            "openness": self.openness,
-            "tool_usage": self.tool_usage,
-            "submitter_name": self.submitter_name,
-            "submitter_email": self.submitter_email,
-        }
-
-
-# Path validation functions
-def _validate_path_component(component: str, allow_underscores: bool = True) -> None:
-    """
-    Validate a single path component.
-    
-    Args:
-        component: The path component to validate
-        allow_underscores: Whether to allow underscores in the component
-        
-    Raises:
-        ValueError: If the component is invalid
-    """
-    if not component:
-        raise ValueError("Path component cannot be empty")
-    
-    if component in (".", ".."):
-        raise ValueError(f"Path component cannot be '{component}'")
-    
-    # Check for invalid characters
-    pattern = r'^[a-zA-Z0-9_\-\.]+$' if allow_underscores else r'^[a-zA-Z0-9\-\.]+$'
-    if not re.match(pattern, component):
-        raise ValueError(
-            f"Path component '{component}' contains invalid characters. "
-            f"Only alphanumeric, hyphens, dots{', and underscores' if allow_underscores else ''} are allowed."
-        )
-
-
-def sanitize_path_component(component: str, replacement: str = "_") -> str:
-    """
-    Sanitize a path component by replacing invalid characters.
-    
-    Args:
-        component: The path component to sanitize
-        replacement: The character to use for replacing invalid characters
-        
-    Returns:
-        Sanitized path component
-    """
-    if not component:
-        return "unnamed"
-    
-    # Replace any non-alphanumeric, non-hyphen, non-dot, non-underscore with replacement
-    sanitized = re.sub(r'[^a-zA-Z0-9_\-\.]', replacement, component)
-    
-    # Remove leading/trailing dots or hyphens
-    sanitized = sanitized.strip('.-')
-    
-    # Collapse multiple replacements into one
-    sanitized = re.sub(f'{re.escape(replacement)}+', replacement, sanitized)
-    
-    if not sanitized:
-        return "unnamed"
-    
-    return sanitized

tests/integration/test_submission.py

@@ -1,108 +0,0 @@
-import json
-import os
-from datetime import datetime
-
-import gradio
-import pytest
-from huggingface_hub import HfApi, hf_hub_download
-
-from aliases import CANONICAL_TOOL_USAGE_STANDARD, CANONICAL_OPENNESS_CLOSED_UI_ONLY
-from config import IS_INTERNAL, CONFIG_NAME, CONTACT_DATASET, SUBMISSION_DATASET
-from submission import add_new_eval
-from submission_utils import SubmissionMetadata
-
-_hf = HfApi()
-
-
-class TestSubmission:
-    @pytest.fixture(autouse=True)
-    def setup(self):
-        # These need to be set before imports are evaluated so all we can do here
-        # is check that they have been set correctly.
-        assert IS_INTERNAL == True
-        assert CONFIG_NAME == "continuous-integration"
-
-    def test_add_new_eval(self, mocker):
-        # Bypass some checks so that the test can cover later parts of the code.
-        mocker.patch("submission._is_hf_acct_too_new", return_value=False)
-        mocker.patch("submission._is_last_submission_too_recent", return_value=False)
-
-        # We use this to find records corresponding to this test.
-        agent_description = f"CI run at {datetime.now().isoformat()}"
-        print(f"Using unique agent description: {agent_description}")
-
-        print("Submitting test submission...")
-        with open(os.path.join(os.path.dirname(__file__), "test-submission.tar.gz"), "rb") as f:
-            result = add_new_eval(
-                val_or_test="test",
-                agent_name="TestSubmissionIntegration",
-                agent_description=agent_description,
-                agent_url="https://github.com/allenai/asta-bench-leaderboard/blob/main/tests/integration/test_submission.py",
-                openness=CANONICAL_OPENNESS_CLOSED_UI_ONLY,
-                degree_of_control=CANONICAL_TOOL_USAGE_STANDARD,
-                path_to_file=f,
-                username="test_user",
-                role="Other",
-                email="jasond+asta_testing@allenai.org",
-                email_opt_in=True,
-                profile=gradio.OAuthProfile({
-                    "name": "Test User",
-                    "preferred_username": "test_user",
-                    "profile": "test_user_profile",
-                    "picture": "https://placecats.com/150/150",
-                }),
-            )
-
-        message, error_modal, success_modal, loading_modal = result
-        assert message == ""  # Success
-        assert error_modal == {'__type__': 'update', 'visible': False}
-        assert success_modal == {'__type__': 'update', 'visible': True}
-        assert loading_modal == {'__type__': 'update', 'visible': False}
-
-        print("Looking up contact record...")
-        contacts = load_dataset(path=CONTACT_DATASET,
-                                name=CONFIG_NAME,
-                                download_mode="force_redownload",
-                                verification_mode=VerificationMode.NO_CHECKS)
-        # There should have been a new entry due to this test with our unique description.
-        found_contact = next(row for row in contacts['test'] if row['agent_description'] == agent_description)
-        assert found_contact
-
-        # This contains an attribute that should lead us to files in the submissions dataset.
-        dataset_url = found_contact['dataset_url']
-        print(f"Found dataset URL: {dataset_url}")
-        assert dataset_url.startswith(
-            "hf://datasets/allenai/asta-bench-internal-submissions/continuous-integration/test/")
-
-        print("Checking submission dataset...")
-        # Commit message itself should link this and the contact record together unambiguously.
-        recent_commits = _hf.list_repo_commits(repo_type="dataset", repo_id=SUBMISSION_DATASET)
-        assert any(dataset_url in c.title for c in recent_commits)
-
-        print("Checking that files are present...")
-        rel_path = dataset_url[len("hf://datasets/allenai/asta-bench-internal-submissions/"):]
-        ds_info = _hf.dataset_info(SUBMISSION_DATASET)
-        # These are the files in our test-submission.tar.gz
-        assert any(f"{rel_path}/eval_config.json" == f.rfilename for f in ds_info.siblings)
-        assert any(f"{rel_path}/task_sqa_solver_openscilm.eval" == f.rfilename for f in ds_info.siblings)
-        # This is the generated metadata put into the dataset itself.
-        assert any(f"{rel_path}/submission.json" == f.rfilename for f in ds_info.siblings)
-
-        print("Checking contact record against submission.json...")
-        # Checks on contact record which is stored in a private dataset.
-        local_path = hf_hub_download(repo_type="dataset",
-                                     repo_id=SUBMISSION_DATASET,
-                                     filename=f"{rel_path}/submission.json")
-        with open(local_path) as f:
-            contact_from_json = json.load(f)
-        # Assert that all keys and values in submission.json are present in the contact record
-        for key, value_from_json in contact_from_json.items():
-            value_from_dataset = found_contact[key]
-            if isinstance(value_from_dataset, datetime):
-                value_from_dataset = found_contact[key].isoformat().replace('+00:00', 'Z')
-            assert value_from_dataset == value_from_json
-        # submission.json should not contain sensitive PII, specifically, email.
-        assert 'email' in found_contact
-        assert 'email' not in contact_from_json
-        # submission.json is defined by a specific data model.
-        SubmissionMetadata.model_validate(contact_from_json)

ui_components.py

@@ -20,6 +20,8 @@ from leaderboard_transformer import (
     format_runtime_column,
     get_pareto_df,
     clean_llm_base_list,
+    get_company_from_model,
+    COMPANY_LOGO_MAP,
 )
 from config import (
     CONFIG_NAME,
@@ -39,56 +41,6 @@ from content import (
 api = HfApi()
 os.makedirs(EXTRACTED_DATA_DIR, exist_ok=True)
 
-# Company logo mapping - maps model name patterns to company logo files
-COMPANY_LOGO_MAP = {
-    "anthropic": {"path": "assets/logo-anthropic.svg", "name": "Anthropic"},
-    "claude": {"path": "assets/logo-anthropic.svg", "name": "Anthropic"},
-    "openai": {"path": "assets/logo-openai.svg", "name": "OpenAI"},
-    "gpt": {"path": "assets/logo-openai.svg", "name": "OpenAI"},
-    "o1": {"path": "assets/logo-openai.svg", "name": "OpenAI"},
-    "o3": {"path": "assets/logo-openai.svg", "name": "OpenAI"},
-    "google": {"path": "assets/logo-google.svg", "name": "Google"},
-    "gemini": {"path": "assets/logo-google.svg", "name": "Google"},
-    "gemma": {"path": "assets/logo-google.svg", "name": "Google"},
-    "meta": {"path": "assets/logo-meta.svg", "name": "Meta"},
-    "llama": {"path": "assets/logo-meta.svg", "name": "Meta"},
-    "mistral": {"path": "assets/logo-mistral.svg", "name": "Mistral"},
-    "mixtral": {"path": "assets/logo-mistral.svg", "name": "Mistral"},
-    "codestral": {"path": "assets/logo-mistral.svg", "name": "Mistral"},
-    "deepseek": {"path": "assets/logo-deepseek.svg", "name": "DeepSeek"},
-    "xai": {"path": "assets/logo-xai.svg", "name": "xAI"},
-    "grok": {"path": "assets/logo-xai.svg", "name": "xAI"},
-    "cohere": {"path": "assets/logo-cohere.svg", "name": "Cohere"},
-    "command": {"path": "assets/logo-cohere.svg", "name": "Cohere"},
-    "qwen": {"path": "assets/logo-qwen.svg", "name": "Qwen"},
-    "alibaba": {"path": "assets/logo-qwen.svg", "name": "Qwen"},
-    "kimi": {"path": "assets/logo-moonshot.svg", "name": "Moonshot"},
-    "moonshot": {"path": "assets/logo-moonshot.svg", "name": "Moonshot"},
-    "minimax": {"path": "assets/logo-minimax.svg", "name": "MiniMax"},
-}
-
-
-def get_company_from_model(model_name: str) -> dict:
-    """
-    Gets the company info (logo path and name) from a model name.
-    Returns default unknown logo if no match found.
-    """
-    if not model_name:
-        return {"path": "assets/logo-unknown.svg", "name": "Unknown"}
-
-    # Handle list of models - use the first one
-    if isinstance(model_name, list):
-        model_name = model_name[0] if model_name else ""
-
-    model_lower = str(model_name).lower()
-
-    # Check each pattern
-    for pattern, company_info in COMPANY_LOGO_MAP.items():
-        if pattern in model_lower:
-            return company_info
-
-    return {"path": "assets/logo-unknown.svg", "name": "Unknown"}
-
 
 def get_company_logo_html(model_name: str) -> str:
     """
@@ -135,26 +87,6 @@ def get_svg_as_data_uri(path: str) -> str:
         print(f"Warning: SVG file not found at {path}")
         return ""
 
-def create_svg_html(value, svg_map):
-    """
-    Generates the absolute simplest HTML for an icon, without any extra text.
-    This version is compatible with gr.DataFrame.
-    """
-    if pd.isna(value) or value not in svg_map:
-        return ""
-
-    path_info = svg_map[value]
-    # Handle both old string format and new object format
-    if isinstance(path_info, dict):
-        path = path_info["path"]
-    else:
-        path = path_info
-
-    src = get_svg_as_data_uri(path)
-    # Generate the HTML for the single icon, with NO text.
-    if src:
-        return f'<img src="{src}" style="width: 16px; height: 16px; vertical-align: middle;" alt="{value}" title="{value}">'
-    return ""
 
 def build_openness_tooltip_content() -> str:
     """
@@ -1355,23 +1287,3 @@ def create_sub_navigation_bar(tag_map: dict, category_name: str, validation: boo
 
     # Return the entire navigation bar as one single Gradio HTML component
     return gr.HTML(full_html)
-
-def format_llm_base_with_html(value):
-    """
-    Formats the 'Models Used' cell value.
-    If the value is a list with more than 1 element, it returns an
-      HTML <span> with the full list in a hover-over tooltip.
-    If it's a single-element list, it returns just that element.
-    Otherwise, it returns the original value.
-    """
-    if isinstance(value, list):
-        if len(value) > 1:
-            # Join the list items with a newline character for a clean tooltip
-            tooltip_text = "\n".join(map(str, value))
-            # Return an HTML span with the title attribute for the tooltip
-            return f'<span class="tooltip-icon cell-tooltip-icon" style="cursor: help;" data-tooltip="{tooltip_text}">{value[0]} (+ {len(value) - 1}) ⓘ</span>'
-        if len(value) == 1:
-            # If only one item, just return that item
-            return value[0]
-    # Return the value as-is if it's not a list or is an empty list
-    return value

visualizations.py

@@ -9,8 +9,9 @@ import os
 import base64
 import aliases
 
-# Import company logo mapping from ui_components
-from ui_components import get_company_from_model, get_svg_as_data_uri
+# Import company logo mapping from leaderboard_transformer
+from leaderboard_transformer import get_company_from_model
+from ui_components import get_svg_as_data_uri
 
 # Standard layout configuration matching existing charts
 # Colors aligned with OpenHands brand