import pandas as pd import numpy as np import gradio as gr import os def process_admissions(file_path, capacity=120): """ Loads, filters, and processes student admission data based on defined rules. Args: file_path (str): The path to the CSV file containing the student data. capacity (int): The maximum number of students to admit. Returns: tuple: A tuple containing: - pd.DataFrame: A DataFrame containing all students with admission status ('正取' or '備取'), or an empty DataFrame if an error occurred or no valid data. - str: The file path to the saved CSV, or None if an error occurred or no valid data. """ try: df = pd.read_csv(file_path) print("DataFrame loaded successfully.") if df is not None: # Filter out rows where any column contains '未填報-未填寫' df_filtered = df[~(df == '未填報-未填寫').any(axis=1)].copy() print(f"DataFrame after filtering: {len(df_filtered)} rows remaining.") if df_filtered.empty: print("No valid entries found after filtering.") return pd.DataFrame(), None # Shuffle the filtered DataFrame to ensure random selection within priority groups #df_shuffled = df_filtered.sample(frac=1, random_state=42).reset_index(drop=True) df_shuffled = df_filtered.sample(frac=1).reset_index(drop=True) admitted_students_list = [] remaining_df = df_shuffled.copy() # Prioritize one person per institution, up to capacity first_admissions_indices = remaining_df.groupby('機關名稱').head(1).index num_first_admissions = min(len(first_admissions_indices), capacity) admitted_students_list.append(remaining_df.loc[first_admissions_indices[:num_first_admissions]]) remaining_df = remaining_df.drop(first_admissions_indices[:num_first_admissions]) # Prioritize a second person per institution if capacity permits current_admitted_count = sum(len(df) for df in admitted_students_list) if current_admitted_count < capacity: second_admissions_indices = remaining_df.groupby('機關名稱').head(1).index additional_capacity = capacity - current_admitted_count num_second_admissions = min(len(second_admissions_indices), additional_capacity) admitted_students_list.append(remaining_df.loc[second_admissions_indices[:num_second_admissions]]) remaining_df = remaining_df.drop(second_admissions_indices[:num_second_admissions]) # Allow more if capacity permits, up to the total capacity current_admitted_count = sum(len(df) for df in admitted_students_list) if current_admitted_count < capacity: additional_capacity = capacity - current_admitted_count additional_admissions_indices = remaining_df.head(additional_capacity).index admitted_students_list.append(remaining_df.loc[additional_admissions_indices]) remaining_df = remaining_df.drop(additional_admissions_indices) # Combine all selected students and drop duplicates admitted_df = pd.concat(admitted_students_list).drop_duplicates().reset_index(drop=True) # Assign '正取' status and order if not admitted_df.empty: admitted_df['錄取順序'] = [f'正取{i+1}' for i in range(len(admitted_df))] # Assign '備取' status to the remaining students if not remaining_df.empty: remaining_df['錄取順序'] = [f'備取{i+1}' for i in range(len(remaining_df))] else: remaining_df['錄取順序'] = [] # Ensure column exists even if empty # Combine admitted and remaining students final_df = pd.concat([admitted_df, remaining_df]).reset_index(drop=True) print("Final Student List with Admission Status:") print(final_df.head()) # 用 print 輸出前幾列 print("\nFinal Student List Info:") print(final_df.info()) # 仍然可以看 info，用 print 包住就好 # Save the processed DataFrame to a temporary CSV file output_csv_path = "admitted_students_processed.csv" final_df.to_csv(output_csv_path, index=False, encoding='utf-8-sig') print(f"Processed data saved to {output_csv_path}") return final_df, output_csv_path else: print("DataFrame not loaded. Cannot perform processing.") return pd.DataFrame(), None except FileNotFoundError: print(f"Error: '{file_path}' not found. Please ensure the file is in the correct directory.") return pd.DataFrame(), None except Exception as e: print(f"An error occurred during processing: {e}") return pd.DataFrame(), None # Assuming process_admissions is defined and available in the environment # It should return a tuple: (DataFrame, file_path) def process_admissions_and_return_df_and_file(file_path, capacity): """ Processes student admission data and returns the DataFrame and the path to the saved CSV. Args: file_path (str): The path to the uploaded CSV file. capacity (int): The maximum number of students to admit. Returns: tuple: A tuple containing: - pd.DataFrame: The processed DataFrame (including 正取 and 備取). - str: The file path to the saved CSV, or None if processing failed. """ final_df, output_csv_path = process_admissions(file_path, capacity) # Call process_admissions which returns final_df and path return final_df, output_csv_path # Return final_df and path if 'process_admissions' in locals(): # Define the Gradio interface interface = gr.Interface( fn=process_admissions_and_return_df_and_file, inputs=[ gr.File(label="Upload CSV File"), gr.Number(label="Admission Capacity", value=120, precision=0) # Add number input for capacity ], outputs=[ gr.Dataframe(label="Admitted Students List"), # Changed label to reflect it includes all students gr.File(label="Download Admitted Students CSV") ], title="Student Admission Processing", description="Upload a CSV file to process student admissions based on institutional priority and capacity, and get a list with admission order and a downloadable CSV." ) print("Gradio interface designed with capacity input.") else: print("The 'process_admissions' function is not defined. Please ensure the data processing logic is defined in a previous step.") if 'interface' in locals(): print("Launching Gradio interface...") interface.launch(debug=True, share=False) else: print("Gradio interface not found. Please ensure the previous steps were executed successfully.")