Update app.py

app.py

@@ -26,6 +26,9 @@ default_harmful_objects = ["knife", "gun", "weapon", "blood", "syringe", "bomb",
 # Case folder storage (in-memory for demo; persist to disk in production)
 case_folders = {}
 
+# Cancellation flag
+cancel_flag = False
+
 # 🔍 Core Features
 # ----------------
 # Resize image to max 1024x1024 while preserving aspect ratio
@@ -106,6 +109,12 @@ def manage_case_folder(case_name: str, results: List[dict], action: str = "add")
 
 # 🛠️ User Options & Controls
 # --------------------------
+# Cancel analysis function
+def cancel_analysis():
+    global cancel_flag
+    cancel_flag = True
+    return "Analysis cancellation requested. Please wait for the current operation to stop."
+
 # Format results as a detailed report
 def format_detailed_report(results, timestamp, keyword: str = ""):
     filtered_results = keyword_search(results, keyword)
@@ -182,6 +191,8 @@ async def predict(
     custom_weights: str = "",
     description_level: str = "detailed"
 ):
+    global cancel_flag
+    cancel_flag = False  # Reset cancellation flag
     if len(files) > 3:
         raise HTTPException(status_code=400, detail="Maximum 3 images allowed.")
     
@@ -204,6 +215,8 @@ async def predict(
     timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
     
     for idx, file in enumerate(files, 1):
+        if cancel_flag:
+            return {"results": results, "analysis_timestamp": timestamp, "status": "Cancelled"}
         try:
             # Check file size (limit to 10MB)
             image_data = await file.read()
@@ -218,21 +231,29 @@ async def predict(
             
             # Core Features
             if metadata:
+                if cancel_flag:
+                    return {"results": results, "analysis_timestamp": timestamp, "status": "Cancelled"}
                 result["metadata"] = extract_metadata(image_data)
             
             if description:
+                if cancel_flag:
+                    return {"results": results, "analysis_timestamp": timestamp, "status": "Cancelled"}
                 prompt_desc = "<image> Provide a " + ("brief description of the image." if description_level == "basic" else "detailed description of the image, including objects, colors, people, and environmental context.")
                 inputs = processor(text=[prompt_desc], images=[image], return_tensors="pt", padding=True)
                 outputs = model.generate(**inputs, max_new_tokens=256 if description_level == "basic" else 512)
                 result["description"] = processor.decode(outputs[0], skip_special_tokens=True).replace(prompt_desc, "").strip() or "No description generated."
             
             if signs:
+                if cancel_flag:
+                    return {"results": results, "analysis_timestamp": timestamp, "status": "Cancelled"}
                 prompt_ocr = "<image> Extract all visible text in the image, such as road signs, license plates, or billboards, with exact wording."
                 inputs_ocr = processor(text=[prompt_ocr], images=[image], return_tensors="pt", padding=True)
                 ocr_outputs = model.generate(**inputs_ocr, max_new_tokens=256)
                 result["signs"] = processor.decode(ocr_outputs[0], skip_special_tokens=True).replace(prompt_ocr, "").strip() or "None detected"
             
             if harmful:
+                if cancel_flag:
+                    return {"results": results, "analysis_timestamp": timestamp, "status": "Cancelled"}
                 prompt_detect = f"<image> Identify any harmful objects ({', '.join(harmful_objects)}) in the image. List them explicitly and estimate confidence (0-100%) for each detection based on clarity."
                 inputs_detect = processor(text=[prompt_detect], images=[image], return_tensors="pt", padding=True)
                 detect_outputs = model.generate(**inputs_detect, max_new_tokens=256)
@@ -245,18 +266,24 @@ async def predict(
                 result["harmful_objects"] = harmful_detected if harmful_detected else [{"object": "None", "confidence": 0}]
             
             if faces:
+                if cancel_flag:
+                    return {"results": results, "analysis_timestamp": timestamp, "status": "Cancelled"}
                 prompt_faces = "<image> Detect faces and estimate attributes such as age range (e.g., child, adult, senior), gender (male, female, unknown), and emotional cues (e.g., neutral, angry, scared)."
                 inputs_faces = processor(text=[prompt_faces], images=[image], return_tensors="pt", padding=True)
                 faces_outputs = model.generate(**inputs_faces, max_new_tokens=256)
                 result["faces"] = processor.decode(faces_outputs[0], skip_special_tokens=True).replace(prompt_faces, "").strip() or "No faces detected"
             
             if objects:
+                if cancel_flag:
+                    return {"results": results, "analysis_timestamp": timestamp, "status": "Cancelled"}
                 prompt_objects = "<image> Identify and localize key objects (e.g., vehicles, weapons, bags) in the image. Provide object names and approximate bounding box coordinates (x_min, y_min, x_max, y_max) in the image."
                 inputs_objects = processor(text=[prompt_objects], images=[image], return_tensors="pt", padding=True)
                 objects_outputs = model.generate(**inputs_objects, max_new_tokens=256)
                 result["objects"] = [{"object": obj.strip(), "bbox": "(unknown)"} for obj in processor.decode(objects_outputs[0], skip_special_tokens=True).replace(prompt_objects, "").split(",") if obj.strip()] or [{"object": "None", "bbox": "N/A"}]
             
             if activity:
+                if cancel_flag:
+                    return {"results": results, "analysis_timestamp": timestamp, "status": "Cancelled"}
                 prompt_activity = "<image> Describe any activities or actions occurring in the image, such as walking, running, or driving."
                 inputs_activity = processor(text=[prompt_activity], images=[image], return_tensors="pt", padding=True)
                 activity_outputs = model.generate(**inputs_activity, max_new_tokens=256)
@@ -264,21 +291,29 @@ async def predict(
             
             # Investigation-Specific Features
             if clothing:
+                if cancel_flag:
+                    return {"results": results, "analysis_timestamp": timestamp, "status": "Cancelled"}
                 prompt_clothing = "<image> Identify clothing items and their colors worn by people in the image."
                 inputs_clothing = processor(text=[prompt_clothing], images=[image], return_tensors="pt", padding=True)
                 clothing_outputs = model.generate(**inputs_clothing, max_new_tokens=256)
                 result["clothing"] = processor.decode(clothing_outputs[0], skip_special_tokens=True).replace(prompt_clothing, "").strip() or "No clothing detected"
             
             if scene:
+                if cancel_flag:
+                    return {"results": results, "analysis_timestamp": timestamp, "status": "Cancelled"}
                 prompt_scene = "<image> Classify the scene type (e.g., indoor, outdoor, urban, rural) and estimate the time of day (e.g., day, night, dusk)."
                 inputs_scene = processor(text=[prompt_scene], images=[image], return_tensors="pt", padding=True)
                 scene_outputs = model.generate(**inputs_scene, max_new_tokens=256)
                 result["scene_context"] = processor.decode(scene_outputs[0], skip_special_tokens=True).replace(prompt_scene, "").strip() or "No context determined"
             
             if threat_score:
+                if cancel_flag:
+                    return {"results": results, "analysis_timestamp": timestamp, "status": "Cancelled"}
                 result["threat_score"] = calculate_threat_score(result.get("harmful_objects", []), weights)
             
             if similarity:
+                if cancel_flag:
+                    return {"results": results, "analysis_timestamp": timestamp, "status": "Cancelled"}
                 inputs_emb = processor(images=[image], return_tensors="pt", padding=True)
                 with torch.no_grad():
                     emb = model.vision_model(inputs_emb["pixel_values"]).last_hidden_state.mean(dim=1).cpu().numpy()
@@ -310,12 +345,14 @@ async def predict(
     if similarity and len(image_embeddings) > 1:
         base_embedding = image_embeddings[0]
         for i in range(1, len(image_embeddings)):
+            if cancel_flag:
+                return {"results": results, "analysis_timestamp": timestamp, "status": "Cancelled"}
             sim = np.dot(base_embedding, image_embeddings[i].T) / (
                 np.linalg.norm(base_embedding) * np.linalg.norm(image_embeddings[i])
             )
             results[i]["similarity_to_image_1"] = float(sim[0][0])
     
-    return {"results": results, "analysis_timestamp": timestamp}
+    return {"results": results, "analysis_timestamp": timestamp, "status": "Completed"}
 
 # Gradio interface
 def gradio_predict(
@@ -345,6 +382,8 @@ def gradio_predict(
     case_folder: str,
     case_action: str
 ):
+    global cancel_flag
+    cancel_flag = False  # Reset cancellation flag
     images = [image_1, image_2, image_3]
     images = [img for img in images if img is not None]
     if not images:
@@ -379,6 +418,11 @@ def gradio_predict(
     errors = []
     
     for idx, image in enumerate(images, 1):
+        if cancel_flag:
+            output = f"**Analysis Cancelled at**: {timestamp}\n"
+            if results:
+                output += "\n**Partial Results**:\n" + format_results(results, timestamp, keyword_search, json_export, detailed_report, case_folder, case_action, filter_attributes, annotation, flag_images, comments, errors)
+            return output
         try:
             # Convert Gradio image input to PIL and resize
             image = Image.fromarray(image).convert("RGB")
@@ -391,21 +435,41 @@ def gradio_predict(
             
             # Core Features
             if metadata:
+                if cancel_flag:
+                    output = f"**Analysis Cancelled at**: {timestamp}\n"
+                    if results:
+                        output += "\n**Partial Results**:\n" + format_results(results, timestamp, keyword_search, json_export, detailed_report, case_folder, case_action, filter_attributes, annotation, flag_images, comments, errors)
+                    return output
                 result["metadata"] = extract_metadata(image_data.getvalue())
             
             if description:
+                if cancel_flag:
+                    output = f"**Analysis Cancelled at**: {timestamp}\n"
+                    if results:
+                        output += "\n**Partial Results**:\n" + format_results(results, timestamp, keyword_search, json_export, detailed_report, case_folder, case_action, filter_attributes, annotation, flag_images, comments, errors)
+                    return output
                 prompt_desc = "<image> Provide a " + ("brief description of the image." if description_level == "basic" else "detailed description of the image, including objects, colors, people, and environmental context.")
                 inputs = processor(text=[prompt_desc], images=[image], return_tensors="pt", padding=True)
                 outputs = model.generate(**inputs, max_new_tokens=256 if description_level == "basic" else 512)
                 result["description"] = processor.decode(outputs[0], skip_special_tokens=True).replace(prompt_desc, "").strip() or "No description generated."
             
             if signs:
+                if cancel_flag:
+                    output = f"**Analysis Cancelled at**: {timestamp}\n"
+                    if results:
+                        output += "\n**Partial Results**:\n" + format_results(results, timestamp, keyword_search, json_export, detailed_report, case_folder, case_action, filter_attributes, annotation, flag_images, comments, errors)
+                    return output
                 prompt_ocr = "<image> Extract all visible text in the image, such as road signs, license plates, or billboards, with exact wording."
                 inputs_ocr = processor(text=[prompt_ocr], images=[image], return_tensors="pt", padding=True)
                 ocr_outputs = model.generate(**inputs_ocr, max_new_tokens=256)
                 result["signs"] = processor.decode(ocr_outputs[0], skip_special_tokens=True).replace(prompt_ocr, "").strip() or "None detected"
             
             if harmful:
+                if cancel_flag:
+                    output = f"**Analysis Cancelled at**: {timestamp}\n"
+                    if results:
+                        output += "\n**Partial Results**:\n" + format_results(results, timestamp, keyword_search, json_export, detailed_report, case_folder, case_action, filter_attributes, annotation, flag_images, comments, errors)
+                    return output
                 prompt_detect = f"<image> Identify any harmful objects ({', '.join(harmful_objects)}) in the image. List them explicitly and estimate confidence (0-100%) for each detection based on clarity."
                 inputs_detect = processor(text=[prompt_detect], images=[image], return_tensors="pt", padding=True)
                 detect_outputs = model.generate(**inputs_detect, max_new_tokens=256)
@@ -418,18 +482,33 @@ def gradio_predict(
                 result["harmful_objects"] = harmful_detected if harmful_detected else [{"object": "None", "confidence": 0}]
             
             if faces:
+                if cancel_flag:
+                    output = f"**Analysis Cancelled at**: {timestamp}\n"
+                    if results:
+                        output += "\n**Partial Results**:\n" + format_results(results, timestamp, keyword_search, json_export, detailed_report, case_folder, case_action, filter_attributes, annotation, flag_images, comments, errors)
+                    return output
                 prompt_faces = "<image> Detect faces and estimate attributes such as age range (e.g., child, adult, senior), gender (male, female, unknown), and emotional cues (e.g., neutral, angry, scared)."
                 inputs_faces = processor(text=[prompt_faces], images=[image], return_tensors="pt", padding=True)
                 faces_outputs = model.generate(**inputs_faces, max_new_tokens=256)
                 result["faces"] = processor.decode(faces_outputs[0], skip_special_tokens=True).replace(prompt_faces, "").strip() or "No faces detected"
             
             if objects:
+                if cancel_flag:
+                    output = f"**Analysis Cancelled at**: {timestamp}\n"
+                    if results:
+                        output += "\n**Partial Results**:\n" + format_results(results, timestamp, keyword_search, json_export, detailed_report, case_folder, case_action, filter_attributes, annotation, flag_images, comments, errors)
+                    return output
                 prompt_objects = "<image> Identify and localize key objects (e.g., vehicles, weapons, bags) in the image. Provide object names and approximate bounding box coordinates (x_min, y_min, x_max, y_max) in the image."
                 inputs_objects = processor(text=[prompt_objects], images=[image], return_tensors="pt", padding=True)
                 objects_outputs = model.generate(**inputs_objects, max_new_tokens=256)
                 result["objects"] = [{"object": obj.strip(), "bbox": "(unknown)"} for obj in processor.decode(objects_outputs[0], skip_special_tokens=True).replace(prompt_objects, "").split(",") if obj.strip()] or [{"object": "None", "bbox": "N/A"}]
             
             if activity:
+                if cancel_flag:
+                    output = f"**Analysis Cancelled at**: {timestamp}\n"
+                    if results:
+                        output += "\n**Partial Results**:\n" + format_results(results, timestamp, keyword_search, json_export, detailed_report, case_folder, case_action, filter_attributes, annotation, flag_images, comments, errors)
+                    return output
                 prompt_activity = "<image> Describe any activities or actions occurring in the image, such as walking, running, or driving."
                 inputs_activity = processor(text=[prompt_activity], images=[image], return_tensors="pt", padding=True)
                 activity_outputs = model.generate(**inputs_activity, max_new_tokens=256)
@@ -437,18 +516,33 @@ def gradio_predict(
             
             # Investigation-Specific Features
             if clothing:
+                if cancel_flag:
+                    output = f"**Analysis Cancelled at**: {timestamp}\n"
+                    if results:
+                        output += "\n**Partial Results**:\n" + format_results(results, timestamp, keyword_search, json_export, detailed_report, case_folder, case_action, filter_attributes, annotation, flag_images, comments, errors)
+                    return output
                 prompt_clothing = "<image> Identify clothing items and their colors worn by people in the image."
                 inputs_clothing = processor(text=[prompt_clothing], images=[image], return_tensors="pt", padding=True)
                 clothing_outputs = model.generate(**inputs_clothing, max_new_tokens=256)
                 result["clothing"] = processor.decode(clothing_outputs[0], skip_special_tokens=True).replace(prompt_clothing, "").strip() or "No clothing detected"
             
             if scene:
+                if cancel_flag:
+                    output = f"**Analysis Cancelled at**: {timestamp}\n"
+                    if results:
+                        output += "\n**Partial Results**:\n" + format_results(results, timestamp, keyword_search, json_export, detailed_report, case_folder, case_action, filter_attributes, annotation, flag_images, comments, errors)
+                    return output
                 prompt_scene = "<image> Classify the scene type (e.g., indoor, outdoor, urban, rural) and estimate the time of day (e.g., day, night, dusk)."
                 inputs_scene = processor(text=[prompt_scene], images=[image], return_tensors="pt", padding=True)
                 scene_outputs = model.generate(**inputs_scene, max_new_tokens=256)
                 result["scene_context"] = processor.decode(scene_outputs[0], skip_special_tokens=True).replace(prompt_scene, "").strip() or "No context determined"
             
             if threat_score:
+                if cancel_flag:
+                    output = f"**Analysis Cancelled at**: {timestamp}\n"
+                    if results:
+                        output += "\n**Partial Results**:\n" + format_results(results, timestamp, keyword_search, json_export, detailed_report, case_folder, case_action, filter_attributes, annotation, flag_images, comments, errors)
+                    return output
                 result["threat_score"] = calculate_threat_score(result.get("harmful_objects", []), weights)
             
             # User Options & Controls
@@ -460,6 +554,11 @@ def gradio_predict(
                 result["comments"] = comments.strip()
             
             if similarity:
+                if cancel_flag:
+                    output = f"**Analysis Cancelled at**: {timestamp}\n"
+                    if results:
+                        output += "\n**Partial Results**:\n" + format_results(results, timestamp, keyword_search, json_export, detailed_report, case_folder, case_action, filter_attributes, annotation, flag_images, comments, errors)
+                    return output
                 inputs_emb = processor(images=[image], return_tensors="pt", padding=True)
                 with torch.no_grad():
                     emb = model.vision_model(inputs_emb["pixel_values"]).last_hidden_state.mean(dim=1).cpu().numpy()
@@ -467,11 +566,7 @@ def gradio_predict(
             
             results.append(result)
         except Exception as e:
-            error_result = {
-                "image_id": f"Image_{idx}",
-                "error": str(e)
-            }
-            errors.append(error_result)
+            errors.append({"image_id": f"Image_{idx}", "error": str(e)})
             result = {
                 "image_id": f"Image_{idx}",
                 "timestamp": timestamp,
@@ -499,6 +594,11 @@ def gradio_predict(
     if similarity and len(image_embeddings) > 1:
         base_embedding = image_embeddings[0]
         for i in range(1, len(image_embeddings)):
+            if cancel_flag:
+                output = f"**Analysis Cancelled at**: {timestamp}\n"
+                if results:
+                    output += "\n**Partial Results**:\n" + format_results(results, timestamp, keyword_search, json_export, detailed_report, case_folder, case_action, filter_attributes, annotation, flag_images, comments, errors)
+                return output
             sim = np.dot(base_embedding, image_embeddings[i].T) / (
                 np.linalg.norm(base_embedding) * np.linalg.norm(image_embeddings[i])
             )
@@ -517,10 +617,18 @@ def gradio_predict(
     
     # Handle case folder
     case_output = ""
-    if case_folder.strip():
+    if case_folder.strip() and not cancel_flag:
         case_output = manage_case_folder(case_folder, results, case_action)
     
-    # Format output for Gradio as tabulated markdown
+    # Format output
+    output = format_results(results, timestamp, keyword_search, json_export, detailed_report, case_folder, case_action, filter_attributes, annotation, flag_images, comments, errors)
+    
+    # Reset cancellation flag
+    cancel_flag = False
+    return output
+
+# Helper function to format results
+def format_results(results, timestamp, keyword_search, json_export, detailed_report, case_folder, case_action, filter_attributes, annotation, flag_images, comments, errors):
     output = f"**Analysis Timestamp**: {timestamp}\n\n"
     headers = ["Image ID"]
     if metadata:
@@ -610,47 +718,72 @@ def gradio_predict(
         output += "\n**Detailed Report**:\n" + format_detailed_report(results, timestamp, keyword_search)
     
     # Append case folder output
-    if case_output:
+    if case_folder.strip() and case_output:
         output += "\n**Case Folder**:\n" + case_output
     
     return output
 
 # Gradio interface
-iface = gr.Interface(
-    fn=gradio_predict,
-    inputs=[
-        gr.Image(label="Upload Image 1 "),
-        gr.Image(label="Upload Image 2 "),
-        gr.Image(label="Upload Image 3 "),
-        gr.Checkbox(label="Description", value=True),
-        gr.Checkbox(label="Signs", value=True),
-        gr.Checkbox(label="Harmful Objects", value=True),
-        gr.Checkbox(label="Similarity", value=True),
-        gr.Checkbox(label="Facial Attributes", value=False),
-        gr.Checkbox(label="Localized Objects", value=False),
-        gr.Checkbox(label="Scene Context", value=False),
-        gr.Checkbox(label="Metadata", value=False),
-        gr.Checkbox(label="Activity Recognition", value=False),
-        gr.Checkbox(label="Clothing/Colors", value=False),
-        gr.Checkbox(label="Threat Score", value=False),
-        gr.Checkbox(label="Combined (All Outputs)", value=False),
-        gr.Checkbox(label="JSON Export", value=False),
-        gr.Checkbox(label="Detailed Report", value=False),
-        gr.Textbox(label="Custom Harmful Objects (comma-separated, e.g., handgun, crowbar)", placeholder="Enter objects to detect"),
-        gr.Textbox(label="Custom Weights (e.g., knife:2.0,gun:3.0)", placeholder="Enter object:weight pairs"),
-        gr.Radio(label="Description Level", choices=["basic", "detailed"], value="detailed"),
-        gr.Textbox(label="Keyword Search", placeholder="Enter keywords to filter results"),
-        gr.Textbox(label="Filter by Attributes (comma-separated)", placeholder="e.g., red, adult, urban"),
-        gr.Textbox(label="Manual Annotation", placeholder="Add labels or notes to images"),
-        gr.Checkbox(label="Flag Important Images", value=False),
-        gr.Textbox(label="Investigator Comments", placeholder="Add comments or notes"),
-        gr.Textbox(label="Case Folder Name", placeholder="Enter case folder name"),
-        gr.Radio(label="Case Folder Action", choices=["add", "view", "clear"], value="add")
-    ],
-    outputs=gr.Textbox(label="Investigation Results", placeholder="Results will appear here..."),
-    title="VisionSage: Image Analysis for Crime Investigation",
-    description="Upload up to 3 images (up to 10MB each, any resolution) "
-)
+with gr.Blocks() as iface:
+    gr.Markdown("# VisionSage: Image Analysis for Crime Investigation")
+    gr.Markdown("Upload up to 3 images (up to 10MB each, any resolution) and select outputs for investigative analysis. Features include metadata extraction, descriptions, text recognition, object detection, facial analysis, activity recognition, clothing detection, threat scoring, and case management. Export results as JSON or a detailed report.")
+    
+    with gr.Row():
+        image_1 = gr.Image(label="Upload Image 1 (up to 10MB)")
+        image_2 = gr.Image(label="Upload Image 2 (up to 10MB)")
+        image_3 = gr.Image(label="Upload Image 3 (up to 10MB)")
+    
+    with gr.Row():
+        with gr.Column():
+            description = gr.Checkbox(label="Description", value=True)
+            signs = gr.Checkbox(label="Signs", value=True)
+            harmful = gr.Checkbox(label="Harmful Objects", value=True)
+            similarity = gr.Checkbox(label="Similarity", value=True)
+            faces = gr.Checkbox(label="Facial Attributes", value=False)
+            objects = gr.Checkbox(label="Localized Objects", value=False)
+            scene = gr.Checkbox(label="Scene Context", value=False)
+            metadata = gr.Checkbox(label="Metadata", value=False)
+            activity = gr.Checkbox(label="Activity Recognition", value=False)
+            clothing = gr.Checkbox(label="Clothing/Colors", value=False)
+            threat_score = gr.Checkbox(label="Threat Score", value=False)
+            combined = gr.Checkbox(label="Combined (All Outputs)", value=False)
+        
+        with gr.Column():
+            json_export = gr.Checkbox(label="JSON Export", value=False)
+            detailed_report = gr.Checkbox(label="Detailed Report", value=False)
+            custom_harmful = gr.Textbox(label="Custom Harmful Objects (comma-separated, e.g., handgun, crowbar)", placeholder="Enter objects to detect")
+            custom_weights = gr.Textbox(label="Custom Weights (e.g., knife:2.0,gun:3.0)", placeholder="Enter object:weight pairs")
+            description_level = gr.Radio(label="Description Level", choices=["basic", "detailed"], value="detailed")
+            keyword_search = gr.Textbox(label="Keyword Search", placeholder="Enter keywords to filter results")
+            filter_attributes = gr.Textbox(label="Filter by Attributes (comma-separated)", placeholder="e.g., red, adult, urban")
+            annotation = gr.Textbox(label="Manual Annotation", placeholder="Add labels or notes to images")
+            flag_images = gr.Checkbox(label="Flag Important Images", value=False)
+            comments = gr.Textbox(label="Investigator Comments", placeholder="Add comments or notes")
+            case_folder = gr.Textbox(label="Case Folder Name", placeholder="Enter case folder name")
+            case_action = gr.Radio(label="Case Folder Action", choices=["add", "view", "clear"], value="add")
+    
+    with gr.Row():
+        submit_button = gr.Button("Submit")
+        cancel_button = gr.Button("Cancel Analysis")
+    
+    output = gr.Textbox(label="Investigation Results", placeholder="Results will appear here...")
+    
+    submit_button.click(
+        fn=gradio_predict,
+        inputs=[
+            image_1, image_2, image_3,
+            description, signs, harmful, similarity, faces, objects, scene, metadata, activity, clothing, threat_score, combined,
+            json_export, detailed_report, custom_harmful, custom_weights, description_level, keyword_search, filter_attributes,
+            annotation, flag_images, comments, case_folder, case_action
+        ],
+        outputs=output
+    )
+    
+    cancel_button.click(
+        fn=cancel_analysis,
+        inputs=[],
+        outputs=output
+    )
 
 if __name__ == "__main__":
     # Launch Gradio interface for Hugging Face Spaces