Adding error catching

app.py

@@ -6,6 +6,7 @@ from pathlib import Path
 import transformers
 import warnings
 import traceback
+import datetime
 
 warnings.filterwarnings("ignore", message=".*copying from a non-meta parameter.*")
 
@@ -14,9 +15,11 @@ current_model = None
 current_processor = None
 current_model_name = None
 
+# Global debug state
+debug_info = {"last_error": "", "step": "", "language": "", "timestamp": ""}
+
 # Available models with better selection
 available_models = {
-    # DETR Models
     "DETR ResNet-50": "facebook/detr-resnet-50",
     "DETR ResNet-101": "facebook/detr-resnet-101",
     "DETR DC5": "facebook/detr-resnet-50-dc5",
@@ -26,18 +29,20 @@ available_models = {
 
 def load_model(model_key):
     """Load model and processor based on selected model key"""
-    global current_model, current_processor, current_model_name
+    global current_model, current_processor, current_model_name, debug_info
 
     model_name = available_models[model_key]
 
     # Only load if it's a different model
     if current_model_name != model_name:
+        debug_info["step"] = f"Loading model: {model_name}"
         print(f"Loading model: {model_name}")
         current_processor = DetrImageProcessor.from_pretrained(model_name)
         current_model = DetrForObjectDetection.from_pretrained(model_name)
         current_model_name = model_name
         print(f"Model loaded: {model_name}")
         print(f"Available labels: {list(current_model.config.id2label.values())}")
+        debug_info["step"] = f"Model loaded successfully: {model_name}"
 
     return current_model, current_processor
 
@@ -48,7 +53,7 @@ if not font_path.exists():
     print(f"Font file {font_path} not found. Using default font.")
     font = ImageFont.load_default()
 else:
-    font = ImageFont.truetype(str(font_path), size=100)  # Reduced font size
+    font = ImageFont.truetype(str(font_path), size=100)
 
 # Set up translations for the app
 translations = {
@@ -62,6 +67,8 @@ translations = {
         "button": "Detect Objects",
         "info_label": "Detection Info",
         "error_label": "Error Messages",
+        "debug_label": "Debug Status",
+        "debug_button": "Show Debug Status",
         "model_fast": "General Objects (fast)",
         "model_precision": "General Objects (high precision)",
         "model_small": "Small Objects/Details (slow)",
@@ -77,6 +84,8 @@ translations = {
         "button": "Detectar objetos",
         "info_label": "Información de detección",
         "error_label": "Mensajes de error",
+        "debug_label": "Estado de depuración",
+        "debug_button": "Mostrar estado de depuración",
         "model_fast": "Objetos generales (rápido)",
         "model_precision": "Objetos generales (precisión alta)",
         "model_small": "Objetos pequeños/detalles (lento)",
@@ -92,6 +101,8 @@ translations = {
         "button": "Détecter les objets",
         "info_label": "Information de détection",
         "error_label": "Messages d'erreur",
+        "debug_label": "État de débogage",
+        "debug_button": "Afficher l'état de débogage",
         "model_fast": "Objets généraux (rapide)",
         "model_precision": "Objets généraux (haute précision)",
         "model_small": "Petits objets/détails (lent)",
@@ -106,6 +117,9 @@ def t(language, key):
 
 def get_translated_model_choices(language):
     """Get model choices translated to the selected language"""
+    global debug_info
+    debug_info["step"] = f"Translating model choices for {language}"
+
     model_mapping = {
         "DETR ResNet-50": "model_fast",
         "DETR ResNet-101": "model_precision",
@@ -119,9 +133,10 @@ def get_translated_model_choices(language):
             translation_key = model_mapping[model_key]
             translated_name = t(language, translation_key)
         else:
-            translated_name = model_key  # Fallback to original name
+            translated_name = model_key
         translated_choices.append(translated_name)
 
+    debug_info["step"] = f"Model choices translated: {translated_choices}"
     return translated_choices
 
 
@@ -160,7 +175,7 @@ def get_helsinki_model(language_label):
     return f"Helsinki-NLP/opus-mt-en-{target}"
 
 
-# add cache for translations
+# Translation cache
 translation_cache = {}
 
 
@@ -189,26 +204,36 @@ def translate_label(language_label, label):
 
 def detect_objects(image, language_selector, translated_model_selector, threshold):
     """Enhanced object detection with adjustable threshold and better info"""
+    global debug_info
+
     try:
+        debug_info["step"] = "Starting object detection"
+        debug_info["timestamp"] = str(datetime.datetime.now())
+
         # Get the actual model key from the translated name
         model_selector = get_model_key_from_translation(translated_model_selector, language_selector)
+        debug_info["step"] = f"Model key resolved: {model_selector}"
 
         print(f"Processing image. Language: {language_selector}, Model: {model_selector}, Threshold: {threshold}")
 
         # Load the selected model
+        debug_info["step"] = "Loading model"
         model, processor = load_model(model_selector)
 
         # Process the image
+        debug_info["step"] = "Processing image with model"
         inputs = processor(images=image, return_tensors="pt")
         outputs = model(**inputs)
 
         # Convert model output to usable detection results with custom threshold
+        debug_info["step"] = "Post-processing results"
         target_sizes = torch.tensor([image.size[::-1]])
         results = processor.post_process_object_detection(
             outputs, threshold=threshold, target_sizes=target_sizes
         )[0]
 
         # Create a copy of the image for drawing
+        debug_info["step"] = "Drawing bounding boxes"
         image_with_boxes = image.copy()
         draw = ImageDraw.Draw(image_with_boxes)
 
@@ -278,15 +303,118 @@ def detect_objects(image, language_selector, translated_model_selector, threshol
         else:
             detection_info += "No objects detected. Try lowering the threshold."
 
-        return image_with_boxes, detection_info, ""  # Empty error message
+        debug_info["step"] = "Detection completed successfully"
+        debug_info["last_error"] = ""
+
+        return image_with_boxes, detection_info, ""
 
     except Exception as e:
         error_message = f"Error in object detection:\n{str(e)}\n\nStack trace:\n{traceback.format_exc()}"
+        debug_info["last_error"] = error_message
+        debug_info["step"] = f"ERROR in detection: {str(e)}"
         print(error_message)
-        # Return original image, error info, and error message
         return image if image else None, "Detection failed. See error panel below.", error_message
 
 
+def update_interface(selected_language):
+    """Update interface language with comprehensive error handling"""
+    global debug_info
+
+    debug_info["language"] = selected_language
+    debug_info["timestamp"] = str(datetime.datetime.now())
+    debug_info["step"] = "Starting language interface update"
+
+    try:
+        debug_info["step"] = "Getting translated model choices"
+        translated_choices = get_translated_model_choices(selected_language)
+
+        debug_info["step"] = "Getting default model translation"
+        default_model = t(selected_language, "model_fast")
+
+        debug_info["step"] = "Creating Gradio updates"
+
+        updates = [
+            gr.update(value=t(selected_language, "title")),
+            gr.update(label=t(selected_language, "dropdown_label")),
+            gr.update(
+                choices=translated_choices,
+                value=default_model,
+                label=t(selected_language, "dropdown_detection_model_label")
+            ),
+            gr.update(label=t(selected_language, "threshold_label")),
+            gr.update(label=t(selected_language, "input_label")),
+            gr.update(value=t(selected_language, "button")),
+            gr.update(label=t(selected_language, "output_label")),
+            gr.update(label=t(selected_language, "info_label")),
+            gr.update(label=t(selected_language, "error_label"), value="", visible=False),
+            gr.update(label=t(selected_language, "debug_label")),
+            gr.update(value=t(selected_language, "debug_button"))
+        ]
+
+        debug_info["step"] = "Interface update completed successfully"
+        debug_info["last_error"] = ""
+
+        return updates
+
+    except Exception as e:
+        error_msg = f"ERROR in interface update at step '{debug_info['step']}':\n{str(e)}\n\nTraceback:\n{traceback.format_exc()}"
+        debug_info["last_error"] = error_msg
+        debug_info["step"] = f"FAILED: {str(e)}"
+
+        # Return safe updates that don't change anything
+        safe_updates = [gr.update() for _ in range(11)]
+        return safe_updates
+
+
+def get_debug_status():
+    """Get current debug status for display"""
+    global debug_info
+
+    status = f"""🔍 DEBUG STATUS:
+Current Language: {debug_info.get('language', 'N/A')}
+Last Timestamp: {debug_info.get('timestamp', 'N/A')}
+Current Step: {debug_info.get('step', 'N/A')}
+Last Error: {debug_info.get('last_error', 'None')}
+
+Available Models: {list(available_models.keys())}
+Current Model: {current_model_name or 'None loaded'}
+Translation Cache Size: {len(translation_cache)}
+"""
+    return status
+
+
+def safe_detect_objects(image, language_selector, translated_model_selector, threshold):
+    """Safe wrapper for object detection with error handling"""
+    global debug_info
+
+    if image is None:
+        debug_info["step"] = "No image provided"
+        return None, "Please upload an image first.", ""
+
+    try:
+        result_image, info, error = detect_objects(image, language_selector, translated_model_selector, threshold)
+
+        # Update error panel visibility based on whether there's an error
+        error_visible = bool(error.strip())
+
+        return (
+            result_image,
+            info,
+            gr.update(value=error, visible=error_visible)
+        )
+
+    except Exception as e:
+        error_message = f"Unexpected error in detection:\n{str(e)}\n\nStack trace:\n{traceback.format_exc()}"
+        debug_info["last_error"] = error_message
+        debug_info["step"] = f"UNEXPECTED ERROR: {str(e)}"
+        print(error_message)
+        return (
+            image,
+            "Detection failed due to unexpected error. See error panel below.",
+            gr.update(value=error_message, visible=True)
+        )
+
+
 def build_app():
     with gr.Blocks(theme=gr.themes.Soft()) as app:
         with gr.Row():
@@ -302,14 +430,14 @@ def build_app():
             with gr.Column(scale=1):
                 model_selector = gr.Dropdown(
                     choices=get_translated_model_choices("English"),
-                    value=t("English", "model_fast"),  # Default to translated "fast" option
+                    value=t("English", "model_fast"),
                     label=t("English", "dropdown_detection_model_label")
                 )
             with gr.Column(scale=1):
                 threshold_slider = gr.Slider(
                     minimum=0.1,
                     maximum=0.95,
-                    value=0.5,  # Lowered default threshold
+                    value=0.5,
                     step=0.05,
                     label=t("English", "threshold_label")
                 )
@@ -336,77 +464,25 @@ def build_app():
                 elem_classes=["error-panel"]
             )
 
-        # Function to update interface when language changes
-        def update_interface(selected_language):
-            try:
-                translated_choices = get_translated_model_choices(selected_language)
-                default_model = t(selected_language, "model_fast")
-
-                return [
-                    gr.update(value=t(selected_language, "title")),
-                    gr.update(label=t(selected_language, "dropdown_label")),
-                    gr.update(
-                        choices=translated_choices,
-                        value=default_model,
-                        label=t(selected_language, "dropdown_detection_model_label")
-                    ),
-                    gr.update(label=t(selected_language, "threshold_label")),
-                    gr.update(label=t(selected_language, "input_label")),
-                    gr.update(value=t(selected_language, "button")),
-                    gr.update(label=t(selected_language, "output_label")),
-                    gr.update(label=t(selected_language, "info_label")),
-                    gr.update(label=t(selected_language, "error_label"), value="", visible=False)  # Clear errors
-                ]
-            except Exception as e:
-                error_message = f"Error updating interface language:\n{str(e)}\n\nStack trace:\n{traceback.format_exc()}"
-                print(error_message)
-
-                # Return safe defaults
-                return [
-                    gr.update(),  # Keep current title
-                    gr.update(),  # Keep current language selector
-                    gr.update(),  # Keep current model selector
-                    gr.update(),  # Keep current threshold
-                    gr.update(),  # Keep current input label
-                    gr.update(),  # Keep current button
-                    gr.update(),  # Keep current output label
-                    gr.update(),  # Keep current info label
-                    gr.update(label="Error Messages", value=error_message, visible=True)  # Show error
-                ]
-
-        # Enhanced detection function with error handling
-        def safe_detect_objects(image, language_selector, translated_model_selector, threshold):
-            if image is None:
-                return None, "Please upload an image first.", ""
-
-            try:
-                result_image, info, error = detect_objects(image, language_selector, translated_model_selector,
-                                                           threshold)
-
-                # Update error panel visibility based on whether there's an error
-                error_visible = bool(error.strip())
-
-                return (
-                    result_image,
-                    info,
-                    gr.update(value=error, visible=error_visible)
-                )
+        # Debug panel - always visible for debugging in HF
+        with gr.Row():
+            debug_panel = gr.Textbox(
+                label=t("English", "debug_label"),
+                lines=10,
+                max_lines=20,
+                value="Application started - ready for debugging",
+                visible=True
+            )
 
-            except Exception as e:
-                error_message = f"Unexpected error in detection:\n{str(e)}\n\nStack trace:\n{traceback.format_exc()}"
-                print(error_message)
-                return (
-                    image,  # Return original image
-                    "Detection failed due to unexpected error. See error panel below.",
-                    gr.update(value=error_message, visible=True)
-                )
+        with gr.Row():
+            debug_button = gr.Button(t("English", "debug_button"), size="sm")
 
         # Connect language change event
         language_selector.change(
             fn=update_interface,
             inputs=language_selector,
             outputs=[title, language_selector, model_selector, threshold_slider,
-                     input_image, button, output_image, detection_info, error_panel],
+                     input_image, button, output_image, detection_info, error_panel, debug_panel, debug_button],
             queue=False
         )
 
@@ -417,11 +493,20 @@ def build_app():
             outputs=[output_image, detection_info, error_panel]
         )
 
+        # Connect debug button click event
+        debug_button.click(
+            fn=get_debug_status,
+            outputs=debug_panel
+        )
+
     return app
 
 
-# Initialize with default model
+# Initialize with default model and debug info
+debug_info["step"] = "Initializing default model"
+debug_info["timestamp"] = str(datetime.datetime.now())
 load_model("DETR ResNet-50")
+debug_info["step"] = "Application ready"
 
 # Launch the application
 if __name__ == "__main__":