[task 2] fix

app.py

@@ -1,6 +1,7 @@
 import os
 import json
 import datetime
+import time
 from email.utils import parseaddr
 
 import gradio as gr
@@ -13,52 +14,122 @@ from huggingface_hub import HfApi, login
 from scorer import instruction_scorer
 from content import format_error, format_warning, format_log, TITLE, INTRODUCTION_TEXT, SUBMISSION_TEXT, CITATION_BUTTON_LABEL, CITATION_BUTTON_TEXT, model_hyperlink
 
+# Set up logging
+import logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Initialize token with better error handling
 TOKEN = os.environ.get("TOKEN", None)
 if TOKEN:
-    login(token=TOKEN)
+    try:
+        login(token=TOKEN)
+        logger.info("Successfully logged in with token")
+    except Exception as e:
+        logger.error(f"Error logging in with token: {e}")
 else:
-    print("Token not found. Please set the HUGGINGFACE_TOKEN environment variable.")
+    logger.warning("Token not found. Please set the HUGGINGFACE_TOKEN environment variable.")
 
+# Constants
 OWNER="Taejin"
 REF_JSONS_SET = f"{OWNER}/speaker_tagging_lb_refs"
 RESULTS_DATASET = f"{OWNER}/spk_tag_results"
 LEADERBOARD_PATH = f"{OWNER}/leaderboard"
 SUBMISSION_DATASET = f"{OWNER}/submission_leaderboard"
-api = HfApi()
-
 YEAR_VERSION = "2024"
 
+# Initialize HfApi with timeout
+api = HfApi(timeout=60)
+
+# File handling functions
 def read_json_file(filepath):
-    with open(filepath) as infile:
-        data_dict = json.load(infile)
-    return data_dict
+    try:
+        with open(filepath) as infile:
+            data_dict = json.load(infile)
+        return data_dict
+    except Exception as e:
+        logger.error(f"Error reading JSON file {filepath}: {e}")
+        raise
 
 def save_json_file(filepath, data_dict):
-    with open(filepath, "w") as outfile:
-        json.dump(data_dict, outfile)
-                                
+    try:
+        with open(filepath, "w") as outfile:
+            json.dump(data_dict, outfile)
+        logger.info(f"Successfully saved JSON to {filepath}")
+    except Exception as e:
+        logger.error(f"Error saving JSON to {filepath}: {e}")
+        raise
+
+# Create necessary directories
 os.makedirs("scored", exist_ok=True)
-print(f"Token loaded-1 : {TOKEN}")
-results_data_files = {"dev": "dev_set_data.csv", "eval": "eval_set_data.csv"}
-results = load_dataset(RESULTS_DATASET, data_files=results_data_files, token=TOKEN, download_mode="force_redownload", ignore_verifications=True)
-
-print(f"Token loaded-2 : {TOKEN}")
-ref_json_files = {"dev_src": "err_dev.src.seglst.json", "dev_ref": "err_dev.ref.seglst.json", "eval_src": "err_eval.src.seglst.json", "eval_ref": "err_eval.ref.seglst.json"}
-ref_jsons = load_dataset(REF_JSONS_SET, data_files=ref_json_files, token=TOKEN, download_mode="force_redownload", ignore_verifications=True)
+os.makedirs("seglst_files", exist_ok=True)
+
+# Load datasets with retry mechanism
+def load_dataset_with_retry(dataset_name, data_files, token, max_retries=3):
+    for attempt in range(max_retries):
+        try:
+            logger.info(f"Loading dataset {dataset_name}, attempt {attempt+1}/{max_retries}")
+            return load_dataset(
+                dataset_name, 
+                data_files=data_files, 
+                token=token, 
+                download_mode="force_redownload", 
+                ignore_verifications=True
+            )
+        except Exception as e:
+            logger.error(f"Error loading dataset {dataset_name}, attempt {attempt+1}: {e}")
+            if attempt < max_retries - 1:
+                time.sleep(2 * (attempt + 1))  # Exponential backoff
+            else:
+                raise
+
+# Load datasets
+try:
+    logger.info(f"Loading results dataset")
+    results_data_files = {"dev": "dev_set_data.csv", "eval": "eval_set_data.csv"}
+    results = load_dataset_with_retry(RESULTS_DATASET, data_files=results_data_files, token=TOKEN)
+    
+    logger.info(f"Loading reference JSON files")
+    ref_json_files = {
+        "dev_src": "err_dev.src.seglst.json", 
+        "dev_ref": "err_dev.ref.seglst.json", 
+        "eval_src": "err_eval.src.seglst.json", 
+        "eval_ref": "err_eval.ref.seglst.json"
+    }
+    ref_jsons = load_dataset_with_retry(REF_JSONS_SET, data_files=ref_json_files, token=TOKEN)
+except Exception as e:
+    logger.error(f"Failed to load datasets: {e}")
+    # We'll continue and let the app handle this gracefully
 
 def get_dataframe_from_results(results, split):
-    df = results[split].to_pandas()
-    df = df.sort_values(by=["cpWER"], ascending=True)
-    return df
-
+    try:
+        df = results[split].to_pandas()
+        df = df.sort_values(by=["cpWER"], ascending=True)
+        return df
+    except Exception as e:
+        logger.error(f"Error creating dataframe for {split}: {e}")
+        # Return empty dataframe as fallback
+        return pd.DataFrame(columns=["System_name", "Method", "Organisation", "cpWER", "errors", "length"])
 
 def restart_space():
-    api.restart_space(repo_id=LEADERBOARD_PATH, token=TOKEN)
+    try:
+        logger.info("Attempting to restart space")
+        api.restart_space(repo_id=LEADERBOARD_PATH, token=TOKEN)
+        logger.info("Space restart request sent successfully")
+    except Exception as e:
+        logger.error(f"Error restarting space: {e}")
 
 TYPES = ["markdown", "markdown", "markdown", "number", "number", "number"]
 
-dev_dataset_dataframe= get_dataframe_from_results(results=results, split="dev")
-eval_dataset_dataframe= get_dataframe_from_results(results=results, split="eval")
+# Initialize dataframes
+try:
+    dev_dataset_dataframe = get_dataframe_from_results(results=results, split="dev")
+    eval_dataset_dataframe = get_dataframe_from_results(results=results, split="eval")
+except Exception as e:
+    logger.error(f"Error initializing dataframes: {e}")
+    # Create empty dataframes as fallback
+    dev_dataset_dataframe = pd.DataFrame(columns=["System_name", "Method", "Organisation", "cpWER", "errors", "length"])
+    eval_dataset_dataframe = pd.DataFrame(columns=["System_name", "Method", "Organisation", "cpWER", "errors", "length"])
 
 def add_new_eval(
     system_name: str,
@@ -67,139 +138,165 @@ def add_new_eval(
     organisation: str,
     mail: str,
 ):
-    print(f"printing all inputs system_name: {system_name},  method: {method}, path_to_file: {path_to_file}, organisation: {organisation}, mail: {mail}")
+    logger.info(f"New evaluation submission: system_name: {system_name}, method: {method}, file: {path_to_file}, org: {organisation}")
 
-    if len(system_name)==0:
-        print("system_name none")
+    # Input validation
+    if len(system_name) == 0:
+        logger.warning("Submission rejected: Empty system name")
         raise gr.Error("Please provide a system_name name. Field empty!")
     
-    if len(method)==0:
-        print("method none")
+    if len(method) == 0:
+        logger.warning("Submission rejected: Empty method")
         raise gr.Error("Please provide a method. Field empty!")
     
-    if len(organisation)==0:
-        print("org none")
+    if len(organisation) == 0:
+        logger.warning("Submission rejected: Empty organisation")
         raise gr.Error("Please provide organisation information. Field empty!")
     
-    # Very basic email parsing
+    # Email validation
     _, parsed_mail = parseaddr(mail)
     if not "@" in parsed_mail:
-        print("email here")
+        logger.warning(f"Submission rejected: Invalid email {mail}")
         raise gr.Error("Please provide a valid email address.")
     
-    # Check if the combination system_name/org already exists and prints a warning message if yes
-    # if system_name.lower() in set([m.lower() for m in results["dev"]["System_name"]]) and organisation.lower() in set([o.lower() for o in results["dev"]["Organisation"]]):
-    #     print("system_name org combo here")
-    #     raise gr.Error("This system_name has been already submitted.")
-
     if path_to_file is None:
-        print("file missing here")
+        logger.warning("Submission rejected: Missing file")
         raise gr.Error("Please attach a file.")
 
-    
-    # Save submitted file
-    time_atm = datetime.datetime.today()
-    api.upload_file(
-        repo_id=SUBMISSION_DATASET, 
-        path_or_fileobj=path_to_file.name, 
-        path_in_repo=f"{organisation}/{system_name}/{YEAR_VERSION}_raw_{time_atm}.json",
-        repo_type="dataset", 
-        token=TOKEN
-    )
+    try:
+        # Save submitted file
+        time_atm = datetime.datetime.today()
+        file_path_in_repo = f"{organisation}/{system_name}/{YEAR_VERSION}_raw_{time_atm}.json"
+        logger.info(f"Uploading submission file to {file_path_in_repo}")
+        
+        api.upload_file(
+            repo_id=SUBMISSION_DATASET, 
+            path_or_fileobj=path_to_file.name, 
+            path_in_repo=file_path_in_repo,
+            repo_type="dataset", 
+            token=TOKEN
+        )
+
+        # Determine mode and reference file
+        if "err_dev.hyp.seglst.json" in path_to_file.name:
+            ref_file_path = "seglst_files/err_dev.ref.seglst.json"
+            mode = "dev"
+        elif "err_eval.hyp.seglst.json" in path_to_file.name:
+            ref_file_path = "seglst_files/err_eval.ref.seglst.json"
+            mode = "eval"
+        else:
+            basename = os.path.basename(path_to_file.name)
+            logger.warning(f"Submission rejected: Invalid filename {basename}")
+            raise gr.Error(f"{basename} is NOT a valid name. It should be either err_dev.hyp.seglst.json or err_eval.hyp.seglst.json")
+        
+        # Compute score
+        logger.info(f"Computing scores for {system_name} in {mode} mode")
+        scores = instruction_scorer(file_path_input=path_to_file.name, ref_file_path=ref_file_path, system_name=system_name)
 
-    # Compute score
-    if "err_dev.hyp.seglst.json" in path_to_file.name:
-        ref_file_path="seglst_files/err_dev.ref.seglst.json"
-        mode = "dev"
-    elif "err_eval.hyp.seglst.json" in path_to_file.name:
-        ref_file_path="seglst_files/err_eval.ref.seglst.json"
-        mode = "eval"
-    else:
-        basename = os.path.basename(path_to_file.name)
-        raise gr.Error(f"{basename} is NOT a valid name. It should be either err_dev.hyp.seglst.json or err_eval.hyp.seglst.json")
-    scores =  instruction_scorer(file_path_input= path_to_file.name, ref_file_path=ref_file_path,  system_name=system_name)
-
-    path_or_fileobj=f"scored/{organisation}_{system_name}.json"
-    scores_and_info = {
+        # Save scores
+        path_or_fileobj = f"scored/{organisation}_{system_name}.json"
+        scores_and_info = {
             "system_name": system_name,
-            "method":method,
+            "method": method,
             "organisation": organisation,
             "email": mail, 
             "cpWER": scores["cpWER"],
             "errors": scores["errors"],
             "length": scores["length"],
         }
-    save_json_file(path_or_fileobj, data_dict=scores_and_info)
-
-    # Save scored file
-    api.upload_file(
-        repo_id=SUBMISSION_DATASET, 
-        path_or_fileobj=path_or_fileobj,
-        path_in_repo=f"{organisation}/{system_name}/{YEAR_VERSION}_scored_{time_atm}.json", 
-        repo_type="dataset", 
-        token=TOKEN
-    )
-
-    # Actual submission
-    eval_entry = {
-        "system_name": system_name,
-        "method":method,
-        "organisation": organisation,
-        "cpWER":scores["cpWER"],
-        "errors":scores["errors"],
-        "length":scores["length"],
-    }
-    
-    if mode == "dev":
-        dev_set_data_csv = "dev_set_data.csv"
-        dev_dataset_dataframe = get_dataframe_from_results(results=results, split="dev")
-        dev_dataset_dataframe = pd.concat([dev_dataset_dataframe, pd.DataFrame([eval_entry])], ignore_index=True)
-        dev_dataset_dataframe.to_csv(dev_set_data_csv, index=False)
+        save_json_file(path_or_fileobj, data_dict=scores_and_info)
 
+        # Upload scored file
+        logger.info(f"Uploading scored file for {system_name}")
         api.upload_file(
-            repo_id=RESULTS_DATASET, 
-            path_or_fileobj=dev_set_data_csv,
-            path_in_repo=dev_set_data_csv,
+            repo_id=SUBMISSION_DATASET, 
+            path_or_fileobj=path_or_fileobj,
+            path_in_repo=f"{organisation}/{system_name}/{YEAR_VERSION}_scored_{time_atm}.json", 
             repo_type="dataset", 
             token=TOKEN
         )
-    elif mode == "eval":
-        eval_set_data_csv = "eval_set_data.csv"
-        eval_dataset_dataframe = get_dataframe_from_results(results=results, split="eval")
-        eval_dataset_dataframe = pd.concat([eval_dataset_dataframe, pd.DataFrame([eval_entry])], ignore_index=True)
-        eval_dataset_dataframe.to_csv(eval_set_data_csv, index=False)
-
-        api.upload_file(
-            repo_id=RESULTS_DATASET, 
-            path_or_fileobj=eval_set_data_csv,
-            path_in_repo=eval_set_data_csv,
-            repo_type="dataset", 
-            token=TOKEN
-        )
-
-    return format_log(f"system_name {system_name} submitted by {organisation} successfully! \nPlease refresh the val leaderboard, and wait a bit to see the score displayed")
 
+        # Prepare entry for results
+        eval_entry = {
+            "System_name": system_name,
+            "Method": method,
+            "Organisation": organisation,
+            "cpWER": scores["cpWER"],
+            "errors": scores["errors"],
+            "length": scores["length"],
+        }
+        
+        # Update appropriate dataset
+        if mode == "dev":
+            dev_set_data_csv = "dev_set_data.csv"
+            dev_dataset_dataframe = get_dataframe_from_results(results=results, split="dev")
+            dev_dataset_dataframe = pd.concat([dev_dataset_dataframe, pd.DataFrame([eval_entry])], ignore_index=True)
+            dev_dataset_dataframe.to_csv(dev_set_data_csv, index=False)
+
+            logger.info(f"Uploading updated dev results for {system_name}")
+            api.upload_file(
+                repo_id=RESULTS_DATASET, 
+                path_or_fileobj=dev_set_data_csv,
+                path_in_repo=dev_set_data_csv,
+                repo_type="dataset", 
+                token=TOKEN
+            )
+        elif mode == "eval":
+            eval_set_data_csv = "eval_set_data.csv"
+            eval_dataset_dataframe = get_dataframe_from_results(results=results, split="eval")
+            eval_dataset_dataframe = pd.concat([eval_dataset_dataframe, pd.DataFrame([eval_entry])], ignore_index=True)
+            eval_dataset_dataframe.to_csv(eval_set_data_csv, index=False)
+
+            logger.info(f"Uploading updated eval results for {system_name}")
+            api.upload_file(
+                repo_id=RESULTS_DATASET, 
+                path_or_fileobj=eval_set_data_csv,
+                path_in_repo=eval_set_data_csv,
+                repo_type="dataset", 
+                token=TOKEN
+            )
+
+        logger.info(f"Submission successful for {system_name} by {organisation}")
+        return format_log(f"System {system_name} submitted by {organisation} successfully! \nPlease refresh the leaderboard, and wait a bit to see the score displayed")
+    
+    except Exception as e:
+        logger.error(f"Error processing submission: {e}")
+        return format_error(f"Error processing submission: {str(e)}")
 
 def refresh():
-    results_data_files = {"dev": "dev_set_data.csv", "eval": "eval_set_data.csv"}
-    results = load_dataset(RESULTS_DATASET, data_files=results_data_files, token=TOKEN, download_mode="force_redownload", ignore_verifications=True)
-    dev_results_dataframe = get_dataframe_from_results(results=results, split="dev")
-    eval_results_dataframe = get_dataframe_from_results(results=results, split="eval")
-    return dev_results_dataframe, eval_results_dataframe
+    try:
+        logger.info("Refreshing leaderboard data")
+        results_data_files = {"dev": "dev_set_data.csv", "eval": "eval_set_data.csv"}
+        results = load_dataset_with_retry(RESULTS_DATASET, data_files=results_data_files, token=TOKEN)
+        dev_results_dataframe = get_dataframe_from_results(results=results, split="dev")
+        eval_results_dataframe = get_dataframe_from_results(results=results, split="eval")
+        return dev_results_dataframe, eval_results_dataframe
+    except Exception as e:
+        logger.error(f"Error refreshing data: {e}")
+        # Return empty dataframes as fallback
+        empty_df = pd.DataFrame(columns=["System_name", "Method", "Organisation", "cpWER", "errors", "length"])
+        return empty_df, empty_df
 
 def upload_file(files):
     file_paths = [file.name for file in files]
     return file_paths
 
-for file_key in ['dev_src', 'dev_ref', 'eval_src', 'eval_ref']:
-    ref_jsons[file_key].to_json(path_or_buf=f"seglst_files/{file_key}.json")
-    buff_list = [x.strip() for x in open(f"seglst_files/{file_key}.json").readlines()]
-    buff_str = ",\n".join(buff_list)
-    seglst_json = f"[\n{buff_str}\n]"
-    split, datatype = file_key.split("_")
-    with open(f"seglst_files/err_{split}.{datatype}.seglst.json", "w") as f:
-        f.write(seglst_json)
-
+# Process reference files
+try:
+    logger.info("Processing reference files")
+    for file_key in ['dev_src', 'dev_ref', 'eval_src', 'eval_ref']:
+        ref_jsons[file_key].to_json(path_or_buf=f"seglst_files/{file_key}.json")
+        buff_list = [x.strip() for x in open(f"seglst_files/{file_key}.json").readlines()]
+        buff_str = ",\n".join(buff_list)
+        seglst_json = f"[\n{buff_str}\n]"
+        split, datatype = file_key.split("_")
+        with open(f"seglst_files/err_{split}.{datatype}.seglst.json", "w") as f:
+            f.write(seglst_json)
+    logger.info("Reference files processed successfully")
+except Exception as e:
+    logger.error(f"Error processing reference files: {e}")
+
+# Create Gradio interface
 demo = gr.Blocks()
 with demo:
     gr.HTML(TITLE)
@@ -221,7 +318,7 @@ with demo:
                 elem_id="citation-button",
             ) 
     with gr.Tab("Results: Dev"):
-        leaderboard_table_dev  = gr.components.Dataframe(
+        leaderboard_table_dev = gr.components.Dataframe(
             value=dev_dataset_dataframe, datatype=TYPES, interactive=False,
             column_widths=["20%"] 
         )
@@ -241,7 +338,7 @@ with demo:
             leaderboard_table_eval,
         ],
     )
-    with gr.Accordion("Submit a new system_name for evaluation"):
+    with gr.Accordion("Submit a new system for evaluation"):
         with gr.Row():
             with gr.Column():
                 system_name_textbox = gr.Textbox(label="System name", type='text')
@@ -251,7 +348,6 @@ with demo:
                 mail = gr.Textbox(label="Contact email (will be stored privately, & used if there is an issue with your submission)", type='email')
                 file_output = gr.File()
 
-
         submit_button = gr.Button("Submit Eval")
         submission_result = gr.Markdown()
         submit_button.click(
@@ -266,7 +362,16 @@ with demo:
             submission_result,
         )
 
-scheduler = BackgroundScheduler()
-scheduler.add_job(restart_space, "interval", seconds=3600)
-scheduler.start()
-demo.launch(debug=True)
+# Set up scheduler with reduced frequency
+try:
+    logger.info("Setting up background scheduler")
+    scheduler = BackgroundScheduler()
+    # Increase interval to reduce resource usage
+    scheduler.add_job(restart_space, "interval", seconds=7200)  # Every 2 hours instead of 1
+    scheduler.start()
+    logger.info("Background scheduler started successfully")
+except Exception as e:
+    logger.error(f"Error setting up scheduler: {e}")
+
+# Launch the app with memory limits
+demo.launch(debug=False)  # Set debug to False in production