Update app.py

app.py

@@ -6,6 +6,12 @@ from pathlib import Path
 from PIL import Image
 from io import BytesIO
 import tempfile
+import shutil
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 # Define categories and their limits
 CATEGORY_LIMITS = {
@@ -15,33 +21,48 @@ CATEGORY_LIMITS = {
 CATEGORIES = list(CATEGORY_LIMITS.keys())
 MAX_SIZE = [1024, 1024]  # Maximum width and height for resized images
 
-class AnnotationManager:
+class ImageProcessor:
     def __init__(self):
-        self.annotations = {}
-        self.temp_dir = tempfile.mkdtemp()  # Create temporary directory for resized images
-    
+        # Create a persistent directory for resized images
+        self.base_dir = os.path.join(tempfile.gettempdir(), "annotation_tool")
+        self.resized_dir = os.path.join(self.base_dir, "resized_images")
+        self._setup_directories()
+        logger.info(f"Initialized ImageProcessor with directory: {self.base_dir}")
+
+    def _setup_directories(self):
+        """Create necessary directories if they don't exist"""
+        os.makedirs(self.resized_dir, exist_ok=True)
+        logger.info(f"Set up directories: {self.resized_dir}")
+
     def resize_image(self, image_path):
-        """Resize image to maximum dimensions while maintaining aspect ratio"""
+        """Resize image and save to persistent directory"""
         try:
-            # Read and resize image
+            logger.info(f"Processing image: {image_path}")
+            
+            # Read original image
             with open(image_path, "rb") as f:
                 img = Image.open(BytesIO(f.read()))
                 img.thumbnail(MAX_SIZE, Image.Resampling.LANCZOS)
             
-            # Save resized image to temporary file
-            filename = os.path.basename(image_path)
-            temp_path = os.path.join(self.temp_dir, f"resized_{filename}")
-            img.save(temp_path)
+            # Create a unique filename for the resized image
+            original_filename = os.path.basename(image_path)
+            resized_filename = f"resized_{original_filename}"
+            resized_path = os.path.join(self.resized_dir, resized_filename)
+            
+            # Save resized image
+            img.save(resized_path)
+            logger.info(f"Saved resized image to: {resized_path}")
+            
+            return resized_path
             
-            return temp_path
         except Exception as e:
-            raise ValueError(f"Error processing image: {str(e)}")
-    
-    def process_image_upload(self, image_path):
-        """Process uploaded image and return path to resized version"""
-        if not image_path:
-            return None
-        return self.resize_image(image_path)
+            logger.error(f"Error processing image: {str(e)}")
+            raise
+
+class AnnotationManager:
+    def __init__(self):
+        self.annotations = {}
+        self.image_processor = ImageProcessor()
     
     def validate_annotations(self, bbox_data):
         """Validate the annotation data and return (is_valid, error_message)"""
@@ -81,6 +102,21 @@ class AnnotationManager:
             
         return True, ""
     
+    def process_upload(self, image_path):
+        """Process uploaded image"""
+        if not image_path:
+            logger.warning("No image path provided")
+            return None
+            
+        try:
+            logger.info(f"Processing upload: {image_path}")
+            resized_path = self.image_processor.resize_image(image_path)
+            logger.info(f"Successfully processed upload: {resized_path}")
+            return resized_path
+        except Exception as e:
+            logger.error(f"Error in process_upload: {str(e)}")
+            return None
+
     def add_annotation(self, bbox_data):
         """Add or update annotations for an image"""
         is_valid, error_msg = self.validate_annotations(bbox_data)
@@ -159,25 +195,38 @@ def create_interface():
             save_btn = gr.Button("Save Current Image Annotations", variant="primary")
             clear_btn = gr.Button("Clear All Annotations", variant="secondary")
 
-        # Add status message
+        # Add status message and debug output
         status_msg = gr.Markdown(label="Status")
+        debug_output = gr.Textbox(label="Debug Info", interactive=False)
         
         # Event handlers
-        def update_image(image_path):
-            if not image_path or not isinstance(image_path, (str, Path)):
-                return None
+        def handle_image_upload(image_path):
             try:
-                resized_path = annotation_mgr.process_image_upload(image_path)
-                return resized_path
+                if not image_path:
+                    return None, "No image uploaded"
+                    
+                logger.info(f"Handling upload for: {image_path}")
+                resized_path = annotation_mgr.process_upload(image_path)
+                
+                if resized_path and os.path.exists(resized_path):
+                    debug_msg = f"Processed image path: {resized_path}"
+                    logger.info(debug_msg)
+                    return resized_path, debug_msg
+                else:
+                    error_msg = "Failed to process image"
+                    logger.error(error_msg)
+                    return None, error_msg
+                    
             except Exception as e:
-                print(f"Error processing image: {e}")
-                return image_path
+                error_msg = f"Error in upload handler: {str(e)}"
+                logger.error(error_msg)
+                return None, error_msg
         
         # Handle image upload and resizing
         bbox_input.upload(
-            fn=update_image,
+            fn=handle_image_upload,
             inputs=[bbox_input],
-            outputs=[bbox_input]
+            outputs=[bbox_input, debug_output]
         )
         
         save_btn.click(