Upload app.py with huggingface_hub

app.py

@@ -24,18 +24,42 @@ import threading
 import queue
 from typing import List, Dict, Any
 
-# In-memory stats for GUI debug display
-gui_stats = {
-    'errors': 0,
-    'warnings': 0,
-    'last_error': 'None',
-    'last_warning': 'None',
-    'last_error_time': '',
-    'last_warning_time': '',
-    'operations_completed': 0,
-    'start_time': datetime.datetime.now(),
-    'tensor_issues': 0
-}
+# SIMPLIFIED LOGGING SETUP - Very direct approach
+# Create output directory if it doesn't exist
+os.makedirs("saved_outputs", exist_ok=True)
+
+# Set up basic logging to both file and console
+log_file = f"saved_outputs/debug_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.log"
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s [%(levelname)s] %(message)s',
+    handlers=[
+        logging.FileHandler(log_file),
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+
+# Create a logger
+logger = logging.getLogger("internvl_app")
+logger.setLevel(logging.DEBUG)
+
+# Log startup information
+logger.info("="*50)
+logger.info("InternVL2.5 Image Analyzer starting up")
+logger.info(f"Log file: {log_file}")
+logger.info(f"Python version: {sys.version}")
+logger.info(f"Torch version: {torch.__version__}")
+logger.info(f"CUDA available: {torch.cuda.is_available()}")
+if torch.cuda.is_available():
+    logger.info(f"CUDA version: {torch.version.cuda}")
+    logger.info(f"GPU: {torch.cuda.get_device_name(0)}")
+logger.info("="*50)
+
+# In-memory stats
+error_count = 0
+warning_count = 0
+last_error = "None"
+last_error_time = ""
 
 # Constants
 IMAGENET_MEAN = (0.485, 0.456, 0.406)
@@ -1087,18 +1111,20 @@ def save_to_html(content, source_type, filename=None):
 # Function to analyze images with a prompt for folder analysis
 def analyze_folder_images(folder_path, prompt):
     """Analyze all images in a folder."""
-    # Add extensive logging to debug panel
+    # Add direct print output for high visibility
+    print(f"\n\n===== FOLDER ANALYSIS STARTED =====")
+    print(f"Folder path: {folder_path}")
+    print(f"Prompt: {prompt}")
+    print(f"Current directory: {os.getcwd()}")
+    print(f"Directory exists: {os.path.exists(folder_path)}")
+    
+    # Log to file system
     logger.info(f"analyze_folder_images called with path: '{folder_path}'")
     
-    # Increment operations counter
-    gui_stats['operations_completed'] += 1
-    
     if not folder_path or folder_path.strip() == "":
         error_msg = "No folder path provided. Please enter a valid folder path."
         logger.error(error_msg)
-        gui_stats['errors'] += 1
-        gui_stats['last_error'] = error_msg
-        gui_stats['last_error_time'] = datetime.datetime.now().strftime("%H:%M:%S")
+        print(f"ERROR: {error_msg}")
         return error_msg
     
     # Clean up the folder path
@@ -1118,12 +1144,10 @@ def analyze_folder_images(folder_path, prompt):
     if os.path.exists("/data"):
         potential_paths.append(os.path.join("/data", folder_path))
     
-    # Debug information
-    logger.debug(f"Current working directory: {os.getcwd()}")
-    try:
-        logger.debug(f"Directory contents of current directory: {os.listdir('.')}")
-    except Exception as e:
-        logger.warning(f"Could not list current directory: {str(e)}")
+    # Print all potential paths for debugging
+    print(f"Trying the following paths:")
+    for i, path in enumerate(potential_paths):
+        print(f"  {i+1}. {path} (exists: {os.path.exists(path)})")
     
     # Try each path
     valid_path = None
@@ -1134,6 +1158,7 @@ def analyze_folder_images(folder_path, prompt):
             if os.path.isdir(test_path):
                 valid_path = test_path
                 logger.info(f"Found valid directory path: '{valid_path}'")
+                print(f"FOUND VALID PATH: {valid_path}")
                 break
             else:
                 logger.debug(f"Path exists but is not a directory: '{test_path}'")
@@ -1141,18 +1166,18 @@ def analyze_folder_images(folder_path, prompt):
     if not valid_path:
         error_msg = f"Could not find a valid directory at '{folder_path}'. Please provide a complete and valid folder path."
         logger.error(error_msg)
-        gui_stats['errors'] += 1
-        gui_stats['last_error'] = error_msg
-        gui_stats['last_error_time'] = datetime.datetime.now().strftime("%H:%M:%S")
+        print(f"ERROR: {error_msg}")
         
         # Try to provide helpful information about available directories
         try:
             available_dirs = [d for d in os.listdir('.') if os.path.isdir(d)]
+            print(f"Available directories in current location: {', '.join(available_dirs)}")
             if available_dirs:
                 return f"Error: {error_msg}\n\nAvailable directories in current location: {', '.join(available_dirs)}"
             else:
                 return f"Error: {error_msg}\n\nNo directories found in the current location."
-        except:
+        except Exception as list_err:
+            print(f"Error listing directories: {str(list_err)}")
             return f"Error: {error_msg}"
     
     # Convert to Path object for easier handling
@@ -1163,58 +1188,81 @@ def analyze_folder_images(folder_path, prompt):
     image_files = []
     for ext in SUPPORTED_EXTENSIONS:
         logger.debug(f"Searching for files with extension: {ext}")
+        print(f"Searching for *{ext} files")
         # Use glob patterns that are case-insensitive
-        image_files.extend(list(folder_path.glob(f"*{ext.lower()}")))
-        image_files.extend(list(folder_path.glob(f"*{ext.upper()}")))
+        found_files = list(folder_path.glob(f"*{ext.lower()}"))
+        found_files.extend(list(folder_path.glob(f"*{ext.upper()}")))
+        image_files.extend(found_files)
+        print(f"Found {len(found_files)} files with extension {ext}")
     
     logger.info(f"Found {len(image_files)} images in {folder_path}")
+    print(f"Total files found: {len(image_files)}")
     
     if not image_files:
         error_msg = f"No supported image files found in '{folder_path}'. Supported formats: {', '.join(SUPPORTED_EXTENSIONS)}"
         logger.warning(error_msg)
-        gui_stats['warnings'] += 1
-        gui_stats['last_warning'] = error_msg
-        gui_stats['last_warning_time'] = datetime.datetime.now().strftime("%H:%M:%S")
+        print(f"WARNING: {error_msg}")
         return error_msg
     
     # Sort the files for consistent output
     image_files.sort()
     
+    # Print filenames for debugging
+    print("Files to process:")
+    for i, file in enumerate(image_files):
+        print(f"  {i+1}. {file.name}")
+    
     results = []
     results.append(f"Found {len(image_files)} images in {folder_path}\n")
     
-    # Load model once for all images
-    logger.info("Loading model for folder analysis")
-    model, tokenizer = load_model()
-    if model is None or tokenizer is None:
-        error_msg = "Error: Could not load model for image analysis"
-        logger.error(error_msg)
-        gui_stats['errors'] += 1
-        gui_stats['last_error'] = error_msg
-        gui_stats['last_error_time'] = datetime.datetime.now().strftime("%H:%M:%S")
-        return error_msg
-    
     # Process each image
     for i, img_path in enumerate(image_files, 1):
         try:
             logger.info(f"Processing image {i}/{len(image_files)}: {img_path.name}")
+            print(f"\nProcessing file {i}/{len(image_files)}: {img_path.name}")
             
             # Check if file is a PDF
             is_pdf = img_path.suffix.lower() == '.pdf'
             
             if is_pdf:
                 logger.info(f"Processing PDF file: {img_path}")
+                print(f"This is a PDF file: {img_path}")
                 try:
                     # Process PDF pages separately
                     logger.debug(f"Converting PDF to images: {img_path}")
-                    pdf_images = process_pdf(pdf_path=str(img_path))
+                    print(f"Converting PDF to images...")
+                    
+                    # Check if file exists and can be read
+                    if not os.path.exists(img_path):
+                        raise FileNotFoundError(f"PDF file not found: {img_path}")
+                    
+                    # Check file size
+                    file_size = os.path.getsize(img_path) / 1024  # KB
+                    print(f"PDF file size: {file_size:.2f} KB")
+                    
+                    try:
+                        # Read a few bytes to check file format
+                        with open(img_path, 'rb') as f:
+                            header = f.read(10)
+                            print(f"File header (hex): {' '.join([f'{b:02x}' for b in header])}")
+                            if not header.startswith(b'%PDF'):
+                                print(f"WARNING: File does not have PDF header")
+                    except Exception as read_err:
+                        print(f"Error reading file header: {str(read_err)}")
+                        
+                    # Try to convert the PDF
+                    try:
+                        pdf_images = convert_from_path(str(img_path))
+                        print(f"PDF converted to {len(pdf_images)} pages")
+                    except Exception as pdf_err:
+                        print(f"Error converting PDF: {str(pdf_err)}")
+                        print(traceback.format_exc())
+                        raise
                     
                     if not pdf_images or len(pdf_images) == 0:
                         error_msg = f"PDF conversion failed for {img_path.name}: No pages extracted"
                         logger.error(error_msg)
-                        gui_stats['errors'] += 1
-                        gui_stats['last_error'] = error_msg
-                        gui_stats['last_error_time'] = datetime.datetime.now().strftime("%H:%M:%S")
+                        print(f"ERROR: {error_msg}")
                         results.append(f"---\nImage {i}/{len(image_files)}: {img_path.name}\nError: PDF conversion failed - no pages extracted\n")
                         continue
                     
@@ -1225,6 +1273,7 @@ def analyze_folder_images(folder_path, prompt):
                     for page_num, page_img in enumerate(pdf_images, 1):
                         try:
                             logger.debug(f"Processing PDF page {page_num}/{len(pdf_images)}")
+                            print(f"Processing PDF page {page_num}/{len(pdf_images)}")
                             page_prompt = f"PDF {img_path.name} - Page {page_num}/{len(pdf_images)}: {prompt}"
                             page_result = process_image_with_text(page_img, page_prompt)
                             pdf_results.append(f"-- Page {page_num} --\n{page_result}")
@@ -1232,9 +1281,8 @@ def analyze_folder_images(folder_path, prompt):
                             error_msg = f"Error processing PDF page {page_num}: {str(page_err)}"
                             logger.error(error_msg)
                             logger.error(traceback.format_exc())
-                            gui_stats['errors'] += 1
-                            gui_stats['last_error'] = error_msg
-                            gui_stats['last_error_time'] = datetime.datetime.now().strftime("%H:%M:%S")
+                            print(f"ERROR: {error_msg}")
+                            print(traceback.format_exc())
                             pdf_results.append(f"-- Page {page_num} --\nError: {str(page_err)}")
                     
                     # Add all PDF results
@@ -1245,16 +1293,17 @@ def analyze_folder_images(folder_path, prompt):
                     error_msg = f"Error processing PDF {img_path.name}: {str(pdf_err)}"
                     logger.error(error_msg)
                     logger.error(traceback.format_exc())
-                    gui_stats['errors'] += 1
-                    gui_stats['last_error'] = error_msg
-                    gui_stats['last_error_time'] = datetime.datetime.now().strftime("%H:%M:%S")
+                    print(f"ERROR: {error_msg}")
+                    print(traceback.format_exc())
                     results.append(f"---\nImage {i}/{len(image_files)}: {img_path.name}\nError processing PDF: {str(pdf_err)}\n")
             else:
                 # Standard image processing
                 try:
                     # Open and process the image
+                    print(f"Processing regular image file")
                     image = Image.open(img_path).convert('RGB')
                     logger.debug(f"Image loaded: size={image.size}, mode={image.mode}")
+                    print(f"Image loaded: size={image.size}, mode={image.mode}")
                     
                     # Process image 
                     image_prompt = f"Image {i}/{len(image_files)} - {img_path.name}: {prompt}"
@@ -1266,24 +1315,24 @@ def analyze_folder_images(folder_path, prompt):
                     
                     # Log success
                     logger.info(f"Successfully processed image {i}/{len(image_files)}: {img_path.name}")
+                    print(f"Successfully processed image {i}/{len(image_files)}: {img_path.name}")
                 except Exception as img_err:
                     error_msg = f"Error opening/processing image {img_path.name}: {str(img_err)}"
                     logger.error(error_msg)
                     logger.error(traceback.format_exc())
-                    gui_stats['errors'] += 1
-                    gui_stats['last_error'] = error_msg
-                    gui_stats['last_error_time'] = datetime.datetime.now().strftime("%H:%M:%S")
+                    print(f"ERROR: {error_msg}")
+                    print(traceback.format_exc())
                     results.append(f"---\nImage {i}/{len(image_files)}: {img_path.name}\nError opening/processing image: {str(img_err)}\n")
             
         except Exception as e:
             error_msg = f"Error processing image {img_path.name}: {str(e)}"
             logger.error(error_msg)
             logger.error(traceback.format_exc())
-            gui_stats['errors'] += 1
-            gui_stats['last_error'] = error_msg
-            gui_stats['last_error_time'] = datetime.datetime.now().strftime("%H:%M:%S")
+            print(f"ERROR: {error_msg}")
+            print(traceback.format_exc())
             results.append(f"---\nImage {i}/{len(image_files)}: {img_path.name}\nError: {str(e)}\n")
     
+    print("===== FOLDER ANALYSIS COMPLETE =====\n\n")
     combined_result = "\n".join(results)
     logger.info(f"Folder analysis complete, processed {len(image_files)} images")
     return combined_result
@@ -1564,24 +1613,6 @@ def get_latest_log_content():
 
 # Main function
 def main():
-    # Create log handler for UI
-    gui_log_handler = GUILogHandler(max_entries=500)
-    gui_log_handler.setFormatter(logging.Formatter('%(asctime)s [%(levelname)s] %(message)s'))
-    gui_log_handler.setLevel(logging.DEBUG)
-    logger.addHandler(gui_log_handler)
-    
-    # Log startup information
-    logger.info("="*50)
-    logger.info("InternVL2.5 Image Analyzer starting up")
-    logger.info(f"Log file: {log_file}")
-    logger.info(f"Python version: {sys.version}")
-    logger.info(f"Torch version: {torch.__version__}")
-    logger.info(f"CUDA available: {torch.cuda.is_available()}")
-    if torch.cuda.is_available():
-        logger.info(f"CUDA version: {torch.version.cuda}")
-        logger.info(f"GPU: {torch.cuda.get_device_name(0)}")
-    logger.info("="*50)
-    
     # Load the model
     model, tokenizer = load_model()
     
@@ -1607,274 +1638,46 @@ def main():
         "Summarize what you see in this image in one paragraph."
     ]
     
-    # Function to get the most recent debug logs
-    def get_debug_logs(num_lines=50):
-        return gui_log_handler.get_logs(last_n=num_lines)
-    
-    # Function to read the full log file
+    # Simple function to read log file
     def read_log_file():
         try:
-            with open(latest_log, 'r') as f:
+            with open(log_file, 'r') as f:
                 return f.read()
         except Exception as e:
             return f"Error reading log file: {str(e)}"
     
-    # Function to update logs in real-time
-    def update_logs(history):
-        latest = gui_log_handler.get_latest()
-        if latest:
-            history = history + "\n" + latest if history else latest
-            # Keep only the last 50 lines for performance
-            lines = history.split("\n")
-            if len(lines) > 50:
-                history = "\n".join(lines[-50:])
-        return history
-    
-    # Function to clear logs
-    def clear_logs():
-        gui_log_handler.clear()
-        return ""
-    
     # Create tabs for different modes
     with gr.Blocks(title="InternVL2.5 Image Analyzer", theme=gr.themes.Soft()) as demo:
         gr.Markdown("# InternVL2.5 Image Analyzer")
         gr.Markdown("Analyze images using the InternVL2.5 model. You can upload individual images or analyze all images in a folder.")
         
-        # Direct logs view tab
-        with gr.Tab("Logs View"):
+        # Add a simple logs view tab first
+        with gr.Tab("Debug Logs"):
             gr.Markdown("## View Application Logs")
-            gr.Markdown("This tab displays the complete application logs for debugging purposes.")
             
             with gr.Row():
-                with gr.Column(scale=4):
-                    full_logs = gr.Textbox(
-                        label="Full Log File", 
+                with gr.Column(scale=3):
+                    logs_output = gr.Textbox(
+                        label="Application Logs",
                         value=read_log_file(),
-                        lines=25,
-                        max_lines=30,
-                        autoscroll=False
+                        lines=30,
+                        max_lines=50
                     )
                 with gr.Column(scale=1):
                     refresh_logs_btn = gr.Button("Refresh Logs")
-                    log_info = gr.Markdown(f"Log file location: {latest_log}")
-                    
-                    # Stats display
-                    stats_html = gr.HTML(format_debug_stats_html())
-                    
-                    # Function to handle automatic log refresh
-                    def refresh_logs():
-                        return read_log_file(), format_debug_stats_html()
-                    
-                    refresh_logs_btn.click(
-                        fn=refresh_logs,
-                        inputs=[],
-                        outputs=[full_logs, stats_html]
-                    )
-                    
-                    # Auto-refresh logs every 10 seconds
-                    gr.on(
-                        triggers=[],
-                        fn=refresh_logs,
-                        inputs=[],
-                        outputs=[full_logs, stats_html],
-                        every=10
-                    )
-                    
-                    # Options for log files
-                    log_files = [f for f in os.listdir(LOGS_DIR) if f.endswith('.log')]
-                    log_dropdown = gr.Dropdown(
-                        label="Available Log Files",
-                        choices=log_files,
-                        value="latest_debug.log" if "latest_debug.log" in log_files else None
-                    )
-                    
-                    # Function to load a specific log file
-                    def load_log_file(filename):
-                        if not filename:
-                            return "No log file selected"
-                        
-                        try:
-                            with open(os.path.join(LOGS_DIR, filename), 'r') as f:
-                                return f.read()
-                        except Exception as e:
-                            return f"Error reading {filename}: {str(e)}"
-                    
-                    log_dropdown.change(
-                        fn=load_log_file,
-                        inputs=[log_dropdown],
-                        outputs=[full_logs]
-                    )
-                    
-                    # Download log file button
-                    def get_current_log_file(filename):
-                        if not filename:
-                            return None
-                        
-                        log_path = os.path.join(LOGS_DIR, filename)
-                        if os.path.exists(log_path):
-                            return log_path
-                        return None
-                    
-                    download_log_btn = gr.Button("Download Selected Log")
-                    log_file_download = gr.File(label="Log File for Download")
-                    
-                    download_log_btn.click(
-                        fn=get_current_log_file,
-                        inputs=[log_dropdown],
-                        outputs=[log_file_download]
-                    )
-        
-        # Debug mode toggle and panel
-        with gr.Accordion("Debug Console", open=False) as debug_accordion:
-            with gr.Row():
-                with gr.Column(scale=4):
-                    debug_output = gr.Textbox(
-                        label="Real-time Debug Logs",
-                        value=get_debug_logs(20),
-                        lines=8,
-                        max_lines=15,
-                        autoscroll=True,
-                        elem_id="debug_output"
-                    )
-                with gr.Column(scale=1):
-                    with gr.Row():
-                        clear_btn = gr.Button("Clear Logs")
-                        refresh_btn = gr.Button("Refresh")
-                    
-                    debug_level = gr.Radio(
-                        ["ERROR", "WARNING", "INFO", "DEBUG"], 
-                        label="Debug Level",
-                        value="INFO"
-                    )
+                    log_info = gr.Markdown(f"Log file: {log_file}")
                     
-                    # Track error counts
-                    error_count = gr.Number(value=0, label="Errors", precision=0)
-                    warning_count = gr.Number(value=0, label="Warnings", precision=0)
-                    
-            # Stats display
-            debug_stats_html = gr.HTML(format_debug_stats_html())
-            
-            # Add option to enable GUI logging for all operations
-            enable_full_logging = gr.Checkbox(label="Log All Operations to Console", value=False)
-            
-            # Function to update stats display
-            def update_stats_display():
-                return format_debug_stats_html()
-            
-            # Set up a timer to update stats every few seconds
-            gr.on(
-                triggers=[debug_accordion.open],
-                fn=update_stats_display,
-                outputs=[debug_stats_html],
-                every=5  # Update every 5 seconds when accordion is open
-            )
-            
-            # Update counts periodically
-            def update_error_counts():
-                return gui_stats['errors'], gui_stats['warnings']
-                
-            gr.on(
-                triggers=[debug_accordion.open],
-                fn=update_error_counts,
-                outputs=[error_count, warning_count],
-                every=2
-            )
-            
-            # Debug info about model
-            with gr.Accordion("Model Information", open=False):
-                if torch.cuda.is_available():
-                    gpu_info = f"CUDA available: {torch.cuda.device_count()} GPU(s)\n"
-                    for i in range(torch.cuda.device_count()):
-                        gpu_info += f"- GPU {i}: {torch.cuda.get_device_name(i)}\n"
-                    gpu_info += f"Total memory: {torch.cuda.get_device_properties(0).total_memory / 1e9:.2f} GB"
-                else:
-                    gpu_info = "CUDA not available - using CPU"
-                
-                gr.Textbox(value=gpu_info, label="GPU Information", lines=4)
-                
-                model_info = f"Model: {MODEL_NAME}\nImage size: {IMAGE_SIZE}x{IMAGE_SIZE}"
-                gr.Textbox(value=model_info, label="Model Configuration", lines=2)
-                
-                # Function to get current memory usage
-                def get_memory_usage():
-                    if torch.cuda.is_available():
-                        allocated = torch.cuda.memory_allocated() / 1e9  # GB
-                        reserved = torch.cuda.memory_reserved() / 1e9    # GB
-                        max_memory = torch.cuda.max_memory_allocated() / 1e9  # GB
-                        return f"Allocated: {allocated:.2f} GB\nReserved: {reserved:.2f} GB\nMax used: {max_memory:.2f} GB"
-                    return "No GPU available"
-                
-                memory_usage = gr.Textbox(
-                    value=get_memory_usage(),
-                    label="Current GPU Memory Usage",
-                    lines=3
-                )
-                
-                # Refresh memory usage
-                refresh_memory_btn = gr.Button("Refresh Memory Info")
-                refresh_memory_btn.click(
-                    fn=get_memory_usage,
-                    inputs=[],
-                    outputs=[memory_usage]
-                )
+                    # Simple error stats
+                    error_stats = gr.Markdown(f"Error count: {error_count}")
             
-            # Download debug logs button
-            gr.Markdown("### Download Complete Debug Logs")
-            
-            def get_log_file_path():
-                return log_file if os.path.exists(log_file) else None
-                
-            download_log_btn = gr.Button("Download Full Log File")
-            log_file_output = gr.File(label="Log File for Download")
-            
-            download_log_btn.click(
-                fn=get_log_file_path,
+            refresh_logs_btn.click(
+                fn=read_log_file,
                 inputs=[],
-                outputs=[log_file_output]
+                outputs=[logs_output]
             )
-        
-        # Set up log level change handler
-        def change_log_level(level):
-            if level == "ERROR":
-                gui_log_handler.setLevel(logging.ERROR)
-                logger.info(f"Debug display log level set to ERROR")
-            elif level == "WARNING":
-                gui_log_handler.setLevel(logging.WARNING)
-                logger.info(f"Debug display log level set to WARNING")
-            elif level == "INFO":
-                gui_log_handler.setLevel(logging.INFO)
-                logger.info(f"Debug display log level set to INFO")
-            else:  # DEBUG
-                gui_log_handler.setLevel(logging.DEBUG)
-                logger.info(f"Debug display log level set to DEBUG")
-            return f"Log level set to {level}"
-        
-        debug_level.change(
-            fn=change_log_level,
-            inputs=[debug_level],
-            outputs=[]
-        )
-        
-        # Button handlers
-        clear_btn.click(
-            fn=clear_logs,
-            inputs=[],
-            outputs=[debug_output]
-        )
-        
-        refresh_btn.click(
-            fn=get_debug_logs,
-            inputs=[],
-            outputs=[debug_output]
-        )
-        
-        # Set up automatic refresh of debug logs
-        debug_output.change(
-            fn=update_logs,
-            inputs=[debug_output],
-            outputs=[debug_output],
-            every=1  # Update every second
-        )
+            
+            # Add download button for log file
+            gr.File(label="Download Log File", value=log_file)
         
         # Main tabs for functionality
         with gr.Tabs():