app.py

import gradio as gr
import pandas as pd
import requests
import os
import shutil
import json
import pandas as pd
import subprocess
import plotly.express as px
def on_confirm(dataset_radio, num_parts_dropdown, token_counts_radio, line_counts_radio, cyclomatic_complexity_radio, problem_type_radio):
   
    num_parts = num_parts_dropdown
    token_counts_split = token_counts_radio
    line_counts_split = line_counts_radio
    cyclomatic_complexity_split = cyclomatic_complexity_radio

    dataframes = []
    # script_path = os.path.abspath(__file__)

    # # 获取当前脚本所在的目录
    # script_dir = os.path.dirname(script_path)
    
    # print("当前脚本文件的绝对路径:", script_path)
    # print("当前脚本文件所在的目录:", script_dir)
    if token_counts_split=="Equal Frequency Partitioning":
        token_counts_df = pd.read_csv(f"/home/user/app/dividing_into_different_subsets/{num_parts}/QS/token_counts_QS.csv")
        dataframes.append(token_counts_df)

    if line_counts_split=="Equal Frequency Partitioning":
        line_counts_df = pd.read_csv(f"E:/python-testn/pythonProject3/hh_1/dividing_into_different_subsets/{num_parts}/QS/line_counts_QS.csv")
        dataframes.append(line_counts_df)

    if cyclomatic_complexity_split=="Equal Frequency Partitioning":
        cyclomatic_complexity_df = pd.read_csv(f"E:/python-testn/pythonProject3/hh_1/dividing_into_different_subsets/{num_parts}/QS/CC_QS.csv")
        dataframes.append(cyclomatic_complexity_df)
  
    if len(dataframes) > 0:
        combined_df = dataframes[0]
        for df in dataframes[1:]:
            combined_df = pd.merge(combined_df, df, left_index=True, right_index=True, suffixes=('', '_y'))
            combined_df = combined_df.loc[:, ~combined_df.columns.str.endswith('_y')] 
        return combined_df
    else:
        return pd.DataFrame()




def execute_specified_python_files(directory_list, file_list):
    for directory in directory_list:
        for py_file in file_list:
            file_path = os.path.join(directory, py_file)
            if os.path.isfile(file_path) and py_file.endswith('.py'):
                print(f"Executing {file_path}...")
                try:
                    subprocess.run(['python', file_path], check=True)
                    print(f"{file_path} executed successfully.")
                except subprocess.CalledProcessError as e:
                    print(f"Error executing {file_path}: {e}")
            else:
                print(f"File {file_path} does not exist or is not a Python file.")




def generate_file(file_obj, user_string, user_number,dataset_choice):
    tmpdir = 'tmpdir'

    
    FilePath = file_obj.name
    print('上传文件的地址：{}'.format(file_obj.name))  

    
    shutil.copy(file_obj.name, tmpdir)

  
    FileName = os.path.basename(file_obj.name)

    print(FilePath)
   
    with open(FilePath, 'r', encoding="utf-8") as file_obj:
       
        outputPath = os.path.join('F:/Desktop/test', FileName)
        data = json.load(file_obj)
        print("data:", data)

        
        with open(outputPath, 'w', encoding="utf-8") as w:
            json.dump(data, w, ensure_ascii=False, indent=4)

       
        file_content = json.dumps(data)  
        url = "http://localhost:6222/submit" 
        files = {'file': (FileName, file_content, 'application/json')}
        payload = {
            'user_string': user_string,
            'user_number': user_number,
            'dataset_choice':dataset_choice
        }

        response = requests.post(url, files=files, data=payload)
        print(response)
        
        if response.status_code == 200:
            
            output_data = response.json()

            
            output_file_path = os.path.join('E:/python-testn/pythonProject3/hh_1/evaluate_result', 'new-model.json')
            with open(output_file_path, 'w', encoding="utf-8") as f:
                json.dump(output_data, f, ensure_ascii=False, indent=4)

            print(f"File saved at: {output_file_path}")

            # 调用更新数据文件的函数
            directory_list = ['/path/to/directory1', '/path/to/directory2'] 
            file_list = ['file1.py', 'file2.py', 'file3.py'] 

            execute_specified_python_files(directory_list, file_list)

            return {"status": "success", "message": "File received and saved"}
        else:
            return {"status": "error", "message": response.text}

        # 返回服务器响应
    return {"status": "success", "message": response.text}

def update_radio_options(token_counts, line_counts, cyclomatic_complexity, problem_type):
    options = []
    if token_counts:
        options.append("Token Counts in Prompt")
    if line_counts:
        options.append("Line Counts in Prompt")
    if cyclomatic_complexity:
        options.append("Cyclomatic Complexity")
    if problem_type:
        options.append("Problem Type")

    return gr.update(choices=options)

def plot_csv(radio,num):
    if radio=="Line Counts in Prompt":
        radio_choice="line_counts"
        file_path = f'E:/python-testn/pythonProject3/hh_1/dividing_into_different_subsets/{num}/QS/{radio_choice}_QS.csv'
    elif radio=="Token Counts in Prompt":
        radio_choice="token_counts"
        file_path = f'E:/python-testn/pythonProject3/hh_1/dividing_into_different_subsets/{num}/QS/{radio_choice}_QS.csv'
    elif radio=="Cyclomatic Complexity":
        radio_choice="CC"
        file_path = f'E:/python-testn/pythonProject3/hh_1/dividing_into_different_subsets/{num}/QS/{radio_choice}_QS.csv'
    elif radio=="Problem Type":
        radio_choice="problem_type"
        file_path = f'E:/python-testn/pythonProject3/hh_1/dividing_into_different_subsets/cata_result.csv'
    
    df = pd.read_csv(file_path)
   
    df.set_index('Model', inplace=True)

    df_transposed = df.T

    fig = px.line(df_transposed, x=df_transposed.index, y=df_transposed.columns,
                  title='Model Evaluation Results',
                  labels={'value': 'Evaluation Score', 'index': 'Evaluation Metric'},
                  color_discrete_sequence=px.colors.qualitative.Plotly)

    fig.update_traces(hovertemplate='%{y}')

    return fig

with gr.Blocks() as iface:
    gr.HTML("""
               <style>
                   .title {
                       text-align: center;
                       font-size: 3em;
                       font-weight: bold;
                       margin-bottom: 0.5em;
                   }
                   .subtitle {
                       text-align: center;
                       font-size: 2em;
                       margin-bottom: 1em;
                   }
               </style>
               <div class="title">📊 Demo-Leaderboard 📊</div>
           """)

    with gr.Tabs() as tabs:
        with gr.TabItem("Evaluation Result"):
            with gr.Row():
                with gr.Column(scale=2):
                    with gr.Row():
                        with gr.Column():
                            dataset_radio = gr.Radio(["HumanEval", "MBPP"], label="Select Dataset ")

                    with gr.Row():
                        custom_css = """  
                            <style>  
                                .markdown-class {  
                                    font-family: 'Helvetica', sans-serif;
                                    font-size: 17px; 
                                    font-weight: bold;  
                                    color: #333; 
                                }  
                            </style>  
                            """

                        with gr.Column():
                            gr.Markdown(
                                f"{custom_css}<div class='markdown-class'> Choose Classification Perspective </div>")

                            token_counts_checkbox = gr.Checkbox(label="Token Counts in Prompt ")
                            line_counts_checkbox = gr.Checkbox(label="Line Counts in Prompt ")
                            cyclomatic_complexity_checkbox = gr.Checkbox(label="Cyclomatic Complexity ")
                            problem_type_checkbox = gr.Checkbox(label="Problem Type ")

                        with gr.Column():
                            gr.Markdown("<div class='markdown-class'>Choose Subsets </div>")
                            num_parts_dropdown = gr.Dropdown(choices=[3, 4, 5, 6, 7, 8], label="Number of Subsets")

            with gr.Row():
                with gr.Column():
                    token_counts_radio = gr.Radio(
                        ["Equal Frequency Partitioning", "Equal Interval Partitioning"], label="Select Dataset",
                        visible=False)
                with gr.Column():
                    line_counts_radio = gr.Radio(
                        ["Equal Frequency Partitioning", "Equal Interval Partitioning"], label="Select Dataset",
                        visible=False)
                with gr.Column():
                    cyclomatic_complexity_radio = gr.Radio(
                        ["Equal Frequency Partitioning", "Equal Interval Partitioning"], label="Select Dataset",
                        visible=False)

            token_counts_checkbox.change(fn=lambda x: toggle_radio(x, token_counts_radio),
                                         inputs=token_counts_checkbox, outputs=token_counts_radio)
            line_counts_checkbox.change(fn=lambda x: toggle_radio(x, line_counts_radio),
                                        inputs=line_counts_checkbox, outputs=line_counts_radio)
            cyclomatic_complexity_checkbox.change(fn=lambda x: toggle_radio(x, cyclomatic_complexity_radio),
                                                  inputs=cyclomatic_complexity_checkbox,
                                                  outputs=cyclomatic_complexity_radio)

            with gr.Tabs() as inner_tabs:
                with gr.TabItem("Leaderboard"):
                    dataframe_output = gr.Dataframe(elem_id="dataframe")
                    css_output = gr.HTML()
                    confirm_button = gr.Button("Confirm ")
                    confirm_button.click(fn=on_confirm, inputs=[dataset_radio, num_parts_dropdown, token_counts_radio,
                                                                line_counts_radio, cyclomatic_complexity_radio],
                                         outputs=dataframe_output)

                with gr.TabItem("Line chart"):
                    select_radio = gr.Radio(choices=[])
                    checkboxes = [token_counts_checkbox, line_counts_checkbox, cyclomatic_complexity_checkbox,
                                  problem_type_checkbox]
                    for checkbox in checkboxes:
                        checkbox.change(fn=update_radio_options, inputs=checkboxes, outputs=select_radio)
                    select_radio.change(fn=plot_csv, inputs=[select_radio, num_parts_dropdown],
                                        outputs=gr.Plot(label="Line Plot "))

        with gr.TabItem("Upload"):
            gr.Markdown("Upload a JSON file")
            with gr.Row():
                with gr.Column():
                    string_input = gr.Textbox(label="Enter the Model Name")
                    number_input = gr.Number(label="Select the Number of Samples")
                    dataset_choice = gr.Dropdown(label="Select Dataset", choices=["humaneval", "mbpp"])
                with gr.Column():
                    file_input = gr.File(label="Upload Generation Result in JSON file")
                    upload_button = gr.Button("Confirm and Upload")

            json_output = gr.JSON(label="")

            upload_button.click(fn=generate_file, inputs=[file_input, string_input, number_input, dataset_choice],
                                outputs=json_output)



    def toggle_radio(checkbox, radio):
        return gr.update(visible=checkbox)



    css = """  
        #scale1 {  
    border: 1px solid rgba(0, 0, 0, 0.2); 
    padding: 10px;  
    border-radius: 8px;   
    background-color: #f9f9f9;  
    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);  
}  
        }  
        """
    gr.HTML(f"<style>{css}</style>")





iface.launch()