Update app.py

mass grading v1.2

app.py

@@ -680,274 +680,193 @@ with gr.Blocks(title="🎓 AI Mass Grading System", theme=gr.themes.Soft()) as d
     gr.Markdown("# 🎓 AI Mass Grading System")
     gr.Markdown("Upload multiple sets of Question Papers, Markschemes, and Answer Sheets for batch processing.")
     
-    # Initialize with one triplet
-    initial_triplet = {
-        "qp_file": None,
-        "ms_file": None, 
-        "ans_file": None,
-        "imprint": False
-    }
-    triplets_state = gr.State([initial_triplet])
-    
-    # Initial triplet row (always visible)
     with gr.Row():
-        qp_file_1 = gr.File(label="📄 Upload Question Paper (PDF)", file_types=[".pdf"])
-        ms_file_1 = gr.File(label="📋 Upload Markscheme (PDF)", file_types=[".pdf"])
-        ans_file_1 = gr.File(label="📝 Upload Student Answer Sheet (PDF)", file_types=[".pdf"])
-    
-    imprint_check_1 = gr.Checkbox(label="✍ Imprint Marks on Student Answer Sheet", value=False)
+        with gr.Column():
+            qp_files = gr.File(
+                label="📄 Upload Question Papers (PDF)", 
+                file_count="multiple", 
+                file_types=[".pdf"]
+            )
+        with gr.Column():
+            ms_files = gr.File(
+                label="📋 Upload Markschemes (PDF)", 
+                file_count="multiple", 
+                file_types=[".pdf"]
+            )
+        with gr.Column():
+            ans_files = gr.File(
+                label="📝 Upload Answer Sheets (PDF)", 
+                file_count="multiple", 
+                file_types=[".pdf"]
+            )
     
-    # Dynamic container for additional triplets
-    additional_triplets = gr.Column()
+    imprint_all = gr.Checkbox(label="✍ Imprint Marks on All Answer Sheets", value=False)
     
-    # Buttons row
     with gr.Row():
-        add_triplet_btn = gr.Button("➕ Add Another Set", variant="secondary")
-        start_grading_btn = gr.Button("🚀 Run Pipeline", variant="primary")
+        start_grading_btn = gr.Button("🚀 Start Mass Grading", variant="primary", size="lg")
     
-    # Status table
+    # Status and results
+    status_info = gr.Markdown("", visible=False)
     status_table = gr.Dataframe(
-        headers=["Set", "QP File", "MS File", "Answer Sheets", "Status"],
+        headers=["Set", "QP File", "MS File", "Answer Sheet", "Status"],
         datatype=["number", "str", "str", "str", "str"],
-        label="📊 Grading Status",
+        label="📊 Grading Progress",
         visible=False
     )
     
-    # Results section
     results_section = gr.Column(visible=False)
     with results_section:
         gr.Markdown("## 📥 Download Results")
-        results_files = gr.Column()
-    
-    def update_first_triplet_qp(file_obj, current_triplets):
-        """Update QP file for first triplet."""
-        current_triplets[0]["qp_file"] = file_obj.name if file_obj else None
-        return current_triplets
-    
-    def update_first_triplet_ms(file_obj, current_triplets):
-        """Update MS file for first triplet."""
-        current_triplets[0]["ms_file"] = file_obj.name if file_obj else None
-        return current_triplets
-    
-    def update_first_triplet_ans(file_obj, current_triplets):
-        """Update AS file for first triplet."""
-        current_triplets[0]["ans_file"] = file_obj.name if file_obj else None
-        return current_triplets
+        results_container = gr.Column()
     
-    def update_first_triplet_imprint(imprint_val, current_triplets):
-        """Update imprint setting for first triplet."""
-        current_triplets[0]["imprint"] = imprint_val
-        return current_triplets
-    
-    def add_triplet(current_triplets):
-        """Add a new triplet to the list."""
-        new_triplet = {
-            "qp_file": None,
-            "ms_file": None, 
-            "ans_file": None,
-            "imprint": False
-        }
-        current_triplets.append(new_triplet)
-        return current_triplets
-    
-    def remove_triplet(triplet_idx, current_triplets):
-        """Remove a triplet from the list."""
-        if triplet_idx < len(current_triplets) and len(current_triplets) > 1:
-            current_triplets.pop(triplet_idx)
-        return current_triplets
+    def create_triplets_from_files(qp_list, ms_list, ans_list, imprint_setting):
+        """Create triplets from uploaded file lists."""
+        if not qp_list or not ms_list or not ans_list:
+            return []
+        
+        # Convert single files to lists
+        if not isinstance(qp_list, list):
+            qp_list = [qp_list] if qp_list else []
+        if not isinstance(ms_list, list):
+            ms_list = [ms_list] if ms_list else []
+        if not isinstance(ans_list, list):
+            ans_list = [ans_list] if ans_list else []
+        
+        # Create triplets by matching files by index
+        triplets = []
+        max_files = max(len(qp_list), len(ms_list), len(ans_list))
+        
+        for i in range(max_files):
+            qp_file = qp_list[i].name if i < len(qp_list) else None
+            ms_file = ms_list[i].name if i < len(ms_list) else None
+            ans_file = ans_list[i].name if i < len(ans_list) else None
+            
+            # Only create triplet if all three files are present
+            if qp_file and ms_file and ans_file:
+                triplets.append({
+                    "qp_file": qp_file,
+                    "ms_file": ms_file,
+                    "ans_file": ans_file,
+                    "imprint": imprint_setting
+                })
+        
+        return triplets
     
-    def update_status_table(triplets):
-        """Update the status table with current triplets."""
-        if len(triplets) <= 1:
-            return gr.update(visible=False, value=[])
+    def update_status_display(qp_list, ms_list, ans_list):
+        """Update the status display showing file matching."""
+        if not qp_list and not ms_list and not ans_list:
+            return gr.update(visible=False), gr.update(visible=False, value=[])
+        
+        # Convert single files to lists
+        if not isinstance(qp_list, list):
+            qp_list = [qp_list] if qp_list else []
+        if not isinstance(ms_list, list):
+            ms_list = [ms_list] if ms_list else []
+        if not isinstance(ans_list, list):
+            ans_list = [ans_list] if ans_list else []
+        
+        max_files = max(len(qp_list), len(ms_list), len(ans_list))
+        
+        if max_files == 0:
+            return gr.update(visible=False), gr.update(visible=False, value=[])
         
+        # Create status info
+        complete_sets = 0
         table_data = []
-        for i, triplet in enumerate(triplets):
-            qp_name = os.path.basename(triplet["qp_file"]) if triplet["qp_file"] else "Not uploaded"
-            ms_name = os.path.basename(triplet["ms_file"]) if triplet["ms_file"] else "Not uploaded"
-            ans_name = os.path.basename(triplet["ans_file"]) if triplet["ans_file"] else "Not uploaded"
+        
+        for i in range(max_files):
+            qp_name = os.path.basename(qp_list[i].name) if i < len(qp_list) else "❌ Missing"
+            ms_name = os.path.basename(ms_list[i].name) if i < len(ms_list) else "❌ Missing"
+            ans_name = os.path.basename(ans_list[i].name) if i < len(ans_list) else "❌ Missing"
             
             # Determine status
-            if triplet["qp_file"] and triplet["ms_file"] and triplet["ans_file"]:
-                status = "📋 Ready"
+            if i < len(qp_list) and i < len(ms_list) and i < len(ans_list):
+                status = "✅ Ready"
+                complete_sets += 1
             else:
-                status = "⏳ Pending uploads"
+                status = "⏳ Incomplete"
             
             table_data.append([i + 1, qp_name, ms_name, ans_name, status])
         
-        return gr.update(visible=True, value=table_data)
-    
-    def start_mass_grading(triplets):
-        """Start processing all triplets."""
-        if not triplets:
-            return gr.update(), gr.update(visible=False)
+        status_text = f"**📊 File Summary:** {complete_sets} complete set(s) ready for grading out of {max_files} total."
         
-        # Filter only complete triplets
-        complete_triplets = [t for t in triplets if t["qp_file"] and t["ms_file"] and t["ans_file"]]
+        return (
+            gr.update(visible=True, value=status_text),
+            gr.update(visible=True, value=table_data)
+        )
+    
+    def process_mass_grading(qp_list, ms_list, ans_list, imprint_setting):
+        """Process all complete triplets."""
+        triplets = create_triplets_from_files(qp_list, ms_list, ans_list, imprint_setting)
         
-        if not complete_triplets:
-            return gr.update(value=[["No complete triplets to process"]]), gr.update(visible=False)
+        if not triplets:
+            return (
+                gr.update(value="❌ No complete sets found. Please ensure each set has QP, MS, and AS files."),
+                gr.update(visible=False),
+                gr.update(visible=False)
+            )
         
-        # Process triplets and update table progressively
-        results = []
+        # Update status to show processing
         table_data = []
-        
-        for i, triplet in enumerate(complete_triplets):
-            # Update status to processing
-            table_row = [
+        for i, triplet in enumerate(triplets):
+            table_data.append([
                 i + 1,
                 os.path.basename(triplet["qp_file"]),
                 os.path.basename(triplet["ms_file"]),
                 os.path.basename(triplet["ans_file"]),
                 "🔄 Processing..."
-            ]
-            table_data.append(table_row)
-            
-            # Process the triplet
-            result = process_single_triplet(triplet, i)
-            results.append(result)
-            
-            # Update status
-            table_data[i][4] = result["status"]
+            ])
         
-        return gr.update(value=table_data), gr.update(visible=True)
-    
-    # Event handlers for first triplet
-    qp_file_1.change(
-        fn=update_first_triplet_qp,
-        inputs=[qp_file_1, triplets_state],
-        outputs=[triplets_state]
-    ).then(
-        fn=update_status_table,
-        inputs=[triplets_state],
-        outputs=[status_table]
-    )
-    
-    ms_file_1.change(
-        fn=update_first_triplet_ms,
-        inputs=[ms_file_1, triplets_state],
-        outputs=[triplets_state]
-    ).then(
-        fn=update_status_table,
-        inputs=[triplets_state],
-        outputs=[status_table]
-    )
-    
-    ans_file_1.change(
-        fn=update_first_triplet_ans,
-        inputs=[ans_file_1, triplets_state],
-        outputs=[triplets_state]
-    ).then(
-        fn=update_status_table,
-        inputs=[triplets_state],
-        outputs=[status_table]
-    )
-    
-    imprint_check_1.change(
-        fn=update_first_triplet_imprint,
-        inputs=[imprint_check_1, triplets_state],
-        outputs=[triplets_state]
-    )
-    
-    # Dynamic UI management for additional triplets
-    @gr.render(inputs=[triplets_state])
-    def render_additional_triplets(triplets):
-        if len(triplets) <= 1:
-            return
+        # Process each triplet
+        results = []
+        result_components = []
         
-        for i in range(1, len(triplets)):  # Start from index 1 (skip first triplet)
-            with gr.Row():
-                qp_file = gr.File(label=f"📄 QP Set {i + 1}", file_types=[".pdf"])
-                ms_file = gr.File(label=f"📋 MS Set {i + 1}", file_types=[".pdf"])
-                ans_file = gr.File(label=f"📝 AS Set {i + 1}", file_types=[".pdf"])
-            
-            with gr.Row():
-                imprint_check = gr.Checkbox(label=f"✍ Imprint Set {i + 1}", value=False)
-                remove_btn = gr.Button("🗑️ Remove", variant="stop", size="sm")
-            
-            # File update handlers
-            def create_file_handler(idx, file_type):
-                def handler(file_obj, current_triplets):
-                    if idx < len(current_triplets):
-                        current_triplets[idx][file_type] = file_obj.name if file_obj else None
-                    return current_triplets
-                return handler
-            
-            def create_imprint_handler(idx):
-                def handler(imprint_val, current_triplets):
-                    if idx < len(current_triplets):
-                        current_triplets[idx]["imprint"] = imprint_val
-                    return current_triplets
-                return handler
-            
-            def create_remove_handler(idx):
-                def handler(current_triplets):
-                    return remove_triplet(idx, current_triplets)
-                return handler
-            
-            # Set up event handlers
-            qp_file.change(
-                fn=create_file_handler(i, "qp_file"),
-                inputs=[qp_file, triplets_state],
-                outputs=[triplets_state]
-            ).then(
-                fn=update_status_table,
-                inputs=[triplets_state],
-                outputs=[status_table]
-            )
-            
-            ms_file.change(
-                fn=create_file_handler(i, "ms_file"),
-                inputs=[ms_file, triplets_state],
-                outputs=[triplets_state]
-            ).then(
-                fn=update_status_table,
-                inputs=[triplets_state],
-                outputs=[status_table]
-            )
-            
-            ans_file.change(
-                fn=create_file_handler(i, "ans_file"),
-                inputs=[ans_file, triplets_state],
-                outputs=[triplets_state]
-            ).then(
-                fn=update_status_table,
-                inputs=[triplets_state],
-                outputs=[status_table]
-            )
-            
-            imprint_check.change(
-                fn=create_imprint_handler(i),
-                inputs=[imprint_check, triplets_state],
-                outputs=[triplets_state]
-            )
+        for i, triplet in enumerate(triplets):
+            print(f"\n🔄 Processing Set {i + 1}/{len(triplets)}")
             
-            remove_btn.click(
-                fn=create_remove_handler(i),
-                inputs=[triplets_state],
-                outputs=[triplets_state]
-            ).then(
-                fn=update_status_table,
-                inputs=[triplets_state],
-                outputs=[status_table]
-            )
+            try:
+                result = process_single_triplet(triplet, i)
+                results.append(result)
+                
+                # Update table status
+                table_data[i][4] = result["status"]
+                
+                # Create download components
+                if result["grading_pdf"]:
+                    result_components.append(
+                        gr.File(value=result["grading_pdf"], label=f"📄 Set {i+1} - Grading PDF", visible=True)
+                    )
+                if result["imprinted_pdf"]:
+                    result_components.append(
+                        gr.File(value=result["imprinted_pdf"], label=f"✍️ Set {i+1} - Imprinted PDF", visible=True)
+                    )
+                    
+            except Exception as e:
+                print(f"❌ Error processing set {i + 1}: {e}")
+                table_data[i][4] = f"❌ Error: {str(e)[:30]}..."
+        
+        # Final status
+        successful = len([r for r in results if r.get("status") == "✅ Complete"])
+        status_text = f"**🏁 Processing Complete:** {successful}/{len(triplets)} sets processed successfully."
+        
+        return (
+            gr.update(value=status_text),
+            gr.update(value=table_data),
+            gr.update(visible=True)
+        )
     
-    # Add triplet button handler
-    add_triplet_btn.click(
-        fn=add_triplet,
-        inputs=[triplets_state],
-        outputs=[triplets_state]
-    ).then(
-        fn=update_status_table,
-        inputs=[triplets_state],
-        outputs=[status_table]
-    )
+    # Event handlers
+    for file_input in [qp_files, ms_files, ans_files]:
+        file_input.change(
+            fn=update_status_display,
+            inputs=[qp_files, ms_files, ans_files],
+            outputs=[status_info, status_table]
+        )
     
-    # Start grading button handler
     start_grading_btn.click(
-        fn=start_mass_grading,
-        inputs=[triplets_state],
-        outputs=[status_table, results_section]
+        fn=process_mass_grading,
+        inputs=[qp_files, ms_files, ans_files, imprint_all],
+        outputs=[status_info, status_table, results_section]
     )
 
 if __name__ == "__main__":