Update app.py

app.py

@@ -3,14 +3,10 @@ import json
 import gradio as gr
 import pandas as pd
 from python_request import process_wod_document
+
 import time
 from dummy import output_test
 
-# --- Global Variables for Timer ---
-processing_start_time = None
-is_processing = False
-analysis_completed = False
-
 # --- Authentication Function ---
 def authenticate_user(username, password):
     """
@@ -19,20 +15,6 @@ def authenticate_user(username, password):
     """
     return username == "demo" and password == os.environ["PASSWORD"]
 
-def update_processing_timer():
-    """
-    Update the processing button with elapsed time ONLY during active processing
-    """
-    global processing_start_time, is_processing, analysis_completed
-    
-    # Only update button during active processing
-    if is_processing and processing_start_time is not None:
-        elapsed = int(time.time() - processing_start_time)
-        return gr.Button(f"Processing... ({elapsed}s)", variant="primary", interactive=False)
-    
-    # Don't interfere with button state when not processing
-    return gr.update()
-
 # --- Core Application Logic ---
 def analyze_wod(file_obj, wod_type):
     """
@@ -43,17 +25,18 @@ def analyze_wod(file_obj, wod_type):
         wod_type: The selected type of Work Order Document.
 
     Returns:
-        A tuple containing: prediction_display, DataFrame, updated button, file_input, type_input
+        A tuple containing: prediction_display, dataframe, and button_update
     """
-    global is_processing, analysis_completed
-    # These checks are now done earlier, but keeping as safety net
+    # Check if user has selected a valid WOD type
     if wod_type == "-- WOD type --" or wod_type is None:
+        # Show warning dialog and return empty DataFrame
         gr.Warning("Please select a WOD type first!")
-        return "", pd.DataFrame(), gr.Button("Analyze Document", variant="primary", interactive=True), file_obj, wod_type
+        return "", pd.DataFrame(), gr.update(value="Analyze Document", interactive=True)
     
+    # Check if file is uploaded
     if file_obj is None:
         gr.Warning("Please upload a PDF file first!")
-        return "", pd.DataFrame(), gr.Button("Analyze Document", variant="primary", interactive=True), file_obj, wod_type
+        return "", pd.DataFrame(), gr.update(value="Analyze Document", interactive=True)
     
     print(f"Analyzing '{file_obj.name}' (Type: {wod_type})...")
     
@@ -71,7 +54,7 @@ def analyze_wod(file_obj, wod_type):
         
         # Process the document using the API
         api_response = process_wod_document(temp_file_path, wod_type)
-        # time.sleep(3)
+        # time.sleep(5)
         # api_response = json.loads(output_test) 
         
         # Clean up temporary file if we created one
@@ -80,13 +63,9 @@ def analyze_wod(file_obj, wod_type):
         
         # Check if API call was successful
         if api_response.get("status") != "success":
-            # Stop processing timer on API error
-            is_processing = False
-            analysis_completed = False
-            
             error_msg = api_response.get("message", "Unknown error occurred")
             gr.Error(f"API Error: {error_msg}")
-            return "", pd.DataFrame(), gr.Button("Analyze Document", variant="primary", interactive=True), file_obj, wod_type
+            return "", pd.DataFrame(), gr.update(value="Analyze Document", interactive=True)
         
         # Parse the API response
         results = api_response.get("results", {})
@@ -117,118 +96,25 @@ def analyze_wod(file_obj, wod_type):
         
         # Get prediction for display
         prediction = results.get("prediction", "Unknown")
-        # gr.Info(f"Analysis completed! Overall prediction: {prediction}")
+        gr.Info(f"Analysis completed! Overall prediction: {prediction}")
         
         # Format prediction as centered H1 for display
         prediction_display = f"<h1 style='text-align: center; color: #1f77b4;'>{prediction}</h1>" if prediction != "Unknown" else ""
         
-        # Stop processing timer and mark analysis as completed
-        is_processing = False
-        analysis_completed = True
-        
-        # Return results with reset button, keeping current inputs
-        return prediction_display, df, gr.Button("Reset", variant="secondary", interactive=True), file_obj, wod_type
+        # Return with Reset button
+        return prediction_display, df, gr.update(value="Reset", interactive=True)
         
     except Exception as e:
-        # Stop processing timer on error
-        is_processing = False
-        analysis_completed = False
-        
         error_msg = f"Error processing document: {str(e)}"
         print(error_msg)
         gr.Error(error_msg)
-        return "", pd.DataFrame(), gr.Button("Analyze Document", variant="primary", interactive=True), file_obj, wod_type
-
-def reset_interface():
-    """
-    Reset the interface to initial state
-    """
-    global analysis_completed, is_processing
-    
-    # Reset global state
-    analysis_completed = False
-    is_processing = False
-    
-    # Create completely clean DataFrame to avoid any pandas confusion
-    clean_df = pd.DataFrame(columns=["Requirement", "Reason", "Status"])
-    
-    return (
-        None,  # Clear file input
-        "-- WOD type --",  # Reset dropdown
-        "",  # Clear prediction output
-        clean_df,  # Clear results with proper columns
-        gr.Button("Analyze Document", variant="primary", interactive=True)  # Reset button
-    )
-
-def check_button_state_and_act(file_obj, wod_type, button_state):
-    """
-    Check button state and decide what to do
-    """
-    # Get button text safely
-    try:
-        button_text = button_state.value if hasattr(button_state, 'value') else str(button_state)
-    except:
-        button_text = "Analyze Document"  # Default fallback
-    
-    # If button shows "Reset", we'll let JavaScript handle the page refresh
-    if "Reset" in button_text:
-        # Return current state - JavaScript will refresh the page
-        clean_df = pd.DataFrame(columns=["Requirement", "Reason", "Status"])
-        return "", clean_df, button_state, file_obj, wod_type
-    
-    # If button shows "Analyze Document", check requirements first
-    elif "Analyze Document" in button_text:
-        # Check if WOD type is selected
-        if wod_type == "-- WOD type --" or wod_type is None:
-            gr.Warning("Please select a WOD type first!")
-            clean_df = pd.DataFrame(columns=["Requirement", "Reason", "Status"])
-            return "", clean_df, gr.Button("Analyze Document", variant="primary", interactive=True), file_obj, wod_type
-        
-        # Check if file is uploaded
-        if file_obj is None:
-            gr.Warning("Please upload a PDF file first!")
-            clean_df = pd.DataFrame(columns=["Requirement", "Reason", "Status"])
-            return "", clean_df, gr.Button("Analyze Document", variant="primary", interactive=True), file_obj, wod_type
-        
-        # All requirements met, start processing timer
-        global processing_start_time, is_processing, analysis_completed
-        processing_start_time = time.time()
-        is_processing = True
-        analysis_completed = False
-        
-        clean_df = pd.DataFrame(columns=["Requirement", "Reason", "Status"])
-        # Return loading state and flag for next step
-        return "", clean_df, gr.Button("Processing... (0s)", variant="primary", interactive=False), file_obj, wod_type
-    
-    # Fallback case
-    return "", pd.DataFrame(columns=["Requirement", "Reason", "Status"]), gr.Button("Analyze Document", variant="primary", interactive=True), file_obj, wod_type
+        return "", pd.DataFrame(), gr.update(value="Analyze Document", interactive=True)
 
-def perform_analysis_if_needed(pred, df, button_state, file_obj, wod_type):
+def reset_app():
     """
-    Perform analysis if button was in processing state
+    Reset function that refreshes the page using JavaScript
     """
-    # Get button text safely
-    try:
-        button_text = button_state.value if hasattr(button_state, 'value') else str(button_state)
-    except:
-        button_text = "Analyze Document"  # Default fallback
-    
-    # If button shows "Processing...", perform analysis
-    if "Processing" in button_text:
-        # Inputs are already validated, proceed with analysis
-        return analyze_wod(file_obj, wod_type)
-    
-    # If button shows "Analyze Document" (after reset or clean state), ensure clean state  
-    elif "Analyze Document" in button_text:
-        # Ensure we have clean DataFrame with proper columns
-        if df.empty or len(df.columns) == 0:
-            clean_df = pd.DataFrame(columns=["Requirement", "Reason", "Status"])
-        else:
-            clean_df = df
-        return pred, clean_df, button_state, file_obj, wod_type
-    
-    # Otherwise, keep current state
-    return pred, df, button_state, file_obj, wod_type
+    return gr.update(value="Analyze Document", interactive=True)
 
 js_func = """
 function refresh() {
@@ -241,13 +127,24 @@ function refresh() {
 }
 """
 
+# JavaScript function to refresh the page when Reset is clicked
+refresh_js = """
+function(button_value) {
+    if (button_value === "Reset") {
+        window.location.reload();
+        return false; // Prevent default action
+    }
+    return true;
+}
+"""
+
 # --- Gradio User Interface Definition ---
 # Using gr.Blocks() for a custom layout that matches the elegant design.
 with gr.Blocks(
     #theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"), 
-    js=js_func,
     theme=gr.themes.Default(primary_hue="blue", secondary_hue="sky"), 
-    css=".gradio-container {max-width: 960px !important; margin: auto !important;}"
+    js=js_func,
+    css=".gradio-container {max-width: 960px !important; margin: auto !important;} .progress-text { display: none !important; }"
 ) as demo:
     
     # Main Title and Description
@@ -291,43 +188,35 @@ with gr.Blocks(
         wrap=True
     )
 
-    # JavaScript to handle reset button  
-    reset_js = """
-    function(file_obj, wod_type, button_state) {
-        // Get button text
-        let button_text = typeof button_state === 'object' && button_state.value ? button_state.value : button_state.toString();
-        
-        // If it's reset button, refresh the page
-        if (button_text.includes('Reset')) {
-            setTimeout(() => {
-                window.location.reload();
-            }, 100);
-        }
-        
-        // Return the inputs as-is for the Python function
-        return [file_obj, wod_type, button_state];
-    }
-    """
-
     # Define the interaction: clicking the button calls the function
+    def handle_button_click(file_obj, wod_type, current_button_value):
+        """Handle button click with state management"""
+        # Check if this is a reset action (this shouldn't be reached due to JS)
+        if current_button_value == "Reset":
+            return "", pd.DataFrame(), gr.update(value="Analyze Document", interactive=True)
+        
+        # Otherwise, this is an analyze action  
+        prediction_display, df, button_update = analyze_wod(file_obj, wod_type)
+        return prediction_display, df, button_update
+    
+    # Set button to Processing state when clicked (only if not Reset)
+    def set_processing_state(current_button_value):
+        if current_button_value == "Reset":
+            return gr.update()  # Don't change if it's reset
+        return gr.update(value="Processing...", interactive=False)
+    
+    # Chain the events: first set processing state, then analyze
     analyze_btn.click(
-        fn=check_button_state_and_act,
-        inputs=[file_input, type_input, analyze_btn],
-        outputs=[prediction_output, results_output, analyze_btn, file_input, type_input],
+        fn=set_processing_state,
+        inputs=[analyze_btn],
+        outputs=[analyze_btn],
         show_progress=False,
-        js=reset_js
+        js=refresh_js  # Add JavaScript to handle reset
     ).then(
-        fn=perform_analysis_if_needed,
-        inputs=[prediction_output, results_output, analyze_btn, file_input, type_input],
-        outputs=[prediction_output, results_output, analyze_btn, file_input, type_input],
-        show_progress=False
-    )
-    
-    # Add timer to update processing button every second
-    timer = gr.Timer(1.0)  # Update every 1 second
-    timer.tick(
-        fn=update_processing_timer,
-        outputs=[analyze_btn]
+        fn=handle_button_click,
+        inputs=[file_input, type_input, analyze_btn],
+        outputs=[prediction_output, results_output, analyze_btn],
+        show_progress=True
     )
 
 # --- Launch the Application with Authentication ---