Create app.py

app.py

@@ -0,0 +1,150 @@
+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)
+
+            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:")
+            display(final_df.head())
+            print("\nFinal Student List Info:")
+            display(final_df.info())
+
+
+            # 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()
+
+else:
+    print("Gradio interface not found. Please ensure the previous steps were executed successfully.")