Upload app.py with huggingface_hub

app.py

@@ -37,52 +37,39 @@ gui_stats = {
     'tensor_issues': 0
 }
 
-# Function to get stats for UI display
-def get_debug_stats():
-    uptime = datetime.datetime.now() - gui_stats['start_time']
-    hours, remainder = divmod(uptime.seconds, 3600)
-    minutes, seconds = divmod(remainder, 60)
-    uptime_str = f"{hours}h {minutes}m {seconds}s"
-    
-    return {
-        'errors': gui_stats['errors'],
-        'warnings': gui_stats['warnings'],
-        'last_error': gui_stats['last_error'],
-        'last_error_time': gui_stats['last_error_time'],
-        'last_warning': gui_stats['last_warning'],
-        'last_warning_time': gui_stats['last_warning_time'],
-        'operations': gui_stats['operations_completed'],
-        'uptime': uptime_str,
-        'tensor_issues': gui_stats['tensor_issues']
-    }
+# Constants
+IMAGENET_MEAN = (0.485, 0.456, 0.406)
+IMAGENET_STD = (0.229, 0.224, 0.225)
 
-# Function to format debug stats as HTML
-def format_debug_stats_html():
-    stats = get_debug_stats()
-    
-    error_color = "#ff5555" if stats['errors'] > 0 else "#555555"
-    warning_color = "#ffaa00" if stats['warnings'] > 0 else "#555555"
-    
-    html = f"""
-    <div style="margin: 10px 0; padding: 10px; border: 1px solid #ddd; border-radius: 4px; background-color: #f9f9f9;">
-        <div style="display: flex; justify-content: space-between;">
-            <div style="flex: 1;">
-                <p><strong>Errors:</strong> <span style="color: {error_color};">{stats['errors']}</span></p>
-                <p><strong>Warnings:</strong> <span style="color: {warning_color};">{stats['warnings']}</span></p>
-                <p><strong>Operations:</strong> {stats['operations']}</p>
-            </div>
-            <div style="flex: 1;">
-                <p><strong>Uptime:</strong> {stats['uptime']}</p>
-                <p><strong>Tensor Issues:</strong> {stats['tensor_issues']}</p>
-            </div>
-        </div>
-        <div style="margin-top: 10px; border-top: 1px solid #ddd; padding-top: 10px;">
-            <p><strong>Last Error:</strong> {stats['last_error_time']} - {stats['last_error']}</p>
-            <p><strong>Last Warning:</strong> {stats['last_warning_time']} - {stats['last_warning']}</p>
-        </div>
-    </div>
-    """
-    return html
+# Configuration
+MODEL_NAME = "OpenGVLab/InternVL2_5-8B"  # Smaller model for faster loading
+IMAGE_SIZE = 448
+OUTPUT_DIR = "saved_outputs"  # Changed to a visible repo directory
+LOGS_DIR = os.path.join(OUTPUT_DIR, "logs")
+
+# Create output and logs directories if they don't exist
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+os.makedirs(LOGS_DIR, exist_ok=True)
+
+# Set up logging to write to saved_outputs/logs directory
+timestamp = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
+log_file = os.path.join(LOGS_DIR, f"debug_log_{timestamp}.log")
+latest_log = os.path.join(LOGS_DIR, "latest_debug.log")
+
+# Configure basic logging first
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s [%(levelname)s] %(message)s',
+    handlers=[
+        logging.FileHandler(log_file),
+        logging.FileHandler(latest_log, mode='w'),  # Overwrite the latest log file
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+
+# Get the root logger
+logger = logging.getLogger()
+logger.setLevel(logging.DEBUG)
 
 # Custom logging handler that captures logs for GUI display
 class GUILogHandler(logging.Handler):
@@ -137,52 +124,52 @@ class GUILogHandler(logging.Handler):
         with self.lock:
             self.log_entries = []
 
-# Constants
-IMAGENET_MEAN = (0.485, 0.456, 0.406)
-IMAGENET_STD = (0.229, 0.224, 0.225)
-
-# Configuration
-MODEL_NAME = "OpenGVLab/InternVL2_5-8B"  # Smaller model for faster loading
-IMAGE_SIZE = 448
-OUTPUT_DIR = "saved_outputs"  # Changed to a visible repo directory
-
-# Create output directory if it doesn't exist
-os.makedirs(OUTPUT_DIR, exist_ok=True)
-
-# Set up logging to write to saved_outputs directory
-log_file = os.path.join(OUTPUT_DIR, f"debug_log_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.log")
-
-# Create a GUI log handler
-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)
-
-# Configure logging
-logging.basicConfig(
-    level=logging.DEBUG,
-    format='%(asctime)s [%(levelname)s] %(message)s',
-    handlers=[
-        logging.FileHandler(log_file),
-        logging.StreamHandler(sys.stdout),
-        gui_log_handler
-    ]
-)
-
-# Create a logger
-logger = logging.getLogger("internvl_analyzer")
-logger.setLevel(logging.DEBUG)
+# Function to get stats for UI display
+def get_debug_stats():
+    uptime = datetime.datetime.now() - gui_stats['start_time']
+    hours, remainder = divmod(uptime.seconds, 3600)
+    minutes, seconds = divmod(remainder, 60)
+    uptime_str = f"{hours}h {minutes}m {seconds}s"
+    
+    return {
+        'errors': gui_stats['errors'],
+        'warnings': gui_stats['warnings'],
+        'last_error': gui_stats['last_error'],
+        'last_error_time': gui_stats['last_error_time'],
+        'last_warning': gui_stats['last_warning'],
+        'last_warning_time': gui_stats['last_warning_time'],
+        'operations': gui_stats['operations_completed'],
+        'uptime': uptime_str,
+        'tensor_issues': gui_stats['tensor_issues']
+    }
 
-# 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)
+# Function to format debug stats as HTML
+def format_debug_stats_html():
+    stats = get_debug_stats()
+    
+    error_color = "#ff5555" if stats['errors'] > 0 else "#555555"
+    warning_color = "#ffaa00" if stats['warnings'] > 0 else "#555555"
+    
+    html = f"""
+    <div style="margin: 10px 0; padding: 10px; border: 1px solid #ddd; border-radius: 4px; background-color: #f9f9f9;">
+        <div style="display: flex; justify-content: space-between;">
+            <div style="flex: 1;">
+                <p><strong>Errors:</strong> <span style="color: {error_color};">{stats['errors']}</span></p>
+                <p><strong>Warnings:</strong> <span style="color: {warning_color};">{stats['warnings']}</span></p>
+                <p><strong>Operations:</strong> {stats['operations']}</p>
+            </div>
+            <div style="flex: 1;">
+                <p><strong>Uptime:</strong> {stats['uptime']}</p>
+                <p><strong>Tensor Issues:</strong> {stats['tensor_issues']}</p>
+            </div>
+        </div>
+        <div style="margin-top: 10px; border-top: 1px solid #ddd; padding-top: 10px;">
+            <p><strong>Last Error:</strong> {stats['last_error_time']} - {stats['last_error']}</p>
+            <p><strong>Last Warning:</strong> {stats['last_warning_time']} - {stats['last_warning']}</p>
+        </div>
+    </div>
+    """
+    return html
 
 # Function to log tensor info for debugging
 def log_tensor_info(tensor, name="tensor"):
@@ -585,83 +572,109 @@ def analyze_dual_images(model, tokenizer, image1, image2, prompt):
         return error_msg
 
 # Function to process PDF files
-def process_pdf(pdf_path=None, pdf_bytes=None):
-    """Convert PDF file to a list of PIL images."""
+def process_pdf(pdf_path=None, pdf_file=None):
+    """Process a PDF file and return a list of PIL images."""
     try:
-        logger.info(f"Processing PDF: {pdf_path}")
-        logger.debug(f"Current working directory: {os.getcwd()}")
+        logger.info(f"Processing PDF: path={pdf_path}, file_upload={pdf_file is not None}")
         
-        if pdf_path:
-            # Convert PDF file pages to PIL images
-            logger.info(f"Converting PDF from path: {pdf_path}")
-            logger.debug(f"PDF path exists: {os.path.exists(pdf_path)}")
-            logger.debug(f"PDF path is file: {os.path.isfile(pdf_path)}")
-            logger.debug(f"PDF file size: {os.path.getsize(pdf_path) if os.path.exists(pdf_path) else 'N/A'} bytes")
+        if pdf_path is not None and os.path.exists(pdf_path):
+            # Log file details
+            file_size = os.path.getsize(pdf_path) / 1024  # KB
+            logger.info(f"PDF file details: path={pdf_path}, size={file_size:.2f} KB")
+            
+            # Direct debug output to console to ensure visibility
+            print(f"[DEBUG] Processing PDF from path: {pdf_path}")
+            print(f"[DEBUG] File exists: {os.path.exists(pdf_path)}, Size: {file_size:.2f} KB")
             
+            # First try to use convert_from_path with detailed logging
             try:
+                logger.debug(f"Converting PDF to images using convert_from_path: {pdf_path}")
+                with open(pdf_path, 'rb') as f:
+                    file_content = f.read()
+                    logger.debug(f"PDF file read: {len(file_content)} bytes")
+                
+                # Log file header for validation
+                if len(file_content) >= 8:
+                    header_hex = ' '.join([f'{b:02x}' for b in file_content[:8]])
+                    logger.info(f"PDF header hex: {header_hex}")
+                    print(f"[DEBUG] PDF header hex: {header_hex}")
+                    
+                    # Check for valid PDF header
+                    if not file_content.startswith(b'%PDF'):
+                        logger.warning(f"File does not have PDF header: {pdf_path}")
+                        print(f"[WARNING] File does not have PDF header: {pdf_path}")
+                
                 images = convert_from_path(pdf_path)
-                logger.info(f"PDF successfully converted to {len(images)} images")
-            except Exception as pdf_err:
-                logger.error(f"Error in convert_from_path: {str(pdf_err)}")
+                logger.info(f"PDF converted successfully using convert_from_path: {len(images)} pages")
+                return images
+            except Exception as path_err:
+                logger.error(f"Error converting PDF using path method: {str(path_err)}")
                 logger.error(traceback.format_exc())
-                # Try with different parameters
-                logger.info("Attempting alternative PDF conversion")
+                print(f"[ERROR] Convert from path failed: {str(path_err)}")
+                
+                # Try fallback method - convert from bytes
                 try:
-                    images = convert_from_path(
-                        pdf_path,
-                        dpi=150,  # Lower DPI for better compatibility
-                        use_pdftocairo=False,  # Try different backend
-                        strict=False  # Be more lenient with errors
-                    )
-                    logger.info(f"Alternative conversion successful: {len(images)} images")
-                except Exception as alt_err:
-                    logger.error(f"Alternative conversion also failed: {str(alt_err)}")
+                    logger.debug("Falling back to convert_from_bytes method")
+                    with open(pdf_path, 'rb') as pdf_file:
+                        pdf_data = pdf_file.read()
+                        logger.debug(f"Read {len(pdf_data)} bytes from PDF file")
+                    
+                    images = convert_from_bytes(pdf_data)
+                    logger.info(f"PDF converted successfully using convert_from_bytes: {len(images)} pages")
+                    return images
+                except Exception as bytes_err:
+                    logger.error(f"Error converting PDF using bytes method: {str(bytes_err)}")
                     logger.error(traceback.format_exc())
+                    print(f"[ERROR] Convert from bytes also failed: {str(bytes_err)}")
                     raise
-        elif pdf_bytes:
-            # Convert PDF bytes to PIL images
-            logger.info("Converting PDF from bytes")
-            logger.debug(f"PDF bytes size: {len(pdf_bytes)} bytes")
+                
+        elif pdf_file is not None:
+            logger.info("Processing uploaded PDF file")
+            print(f"[DEBUG] Processing uploaded PDF file")
+            
+            if hasattr(pdf_file, 'name'):
+                logger.debug(f"Uploaded PDF filename: {pdf_file.name}")
             
             try:
-                images = convert_from_bytes(pdf_bytes)
-                logger.info(f"PDF bytes successfully converted to {len(images)} images")
-            except Exception as bytes_err:
-                logger.error(f"Error in convert_from_bytes: {str(bytes_err)}")
+                # Creating a temporary file from the uploaded file
+                with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as temp_file:
+                    temp_file.write(pdf_file.read())
+                    temp_path = temp_file.name
+                
+                logger.debug(f"Created temporary file: {temp_path}")
+                print(f"[DEBUG] Created temp file: {temp_path}")
+                
+                # Now convert from the temp file
+                images = convert_from_path(temp_path)
+                logger.info(f"PDF converted successfully: {len(images)} pages")
+                
+                # Clean up
+                os.unlink(temp_path)
+                return images
+            except Exception as upload_err:
+                logger.error(f"Error processing uploaded PDF: {str(upload_err)}")
                 logger.error(traceback.format_exc())
-                # Try with different parameters
-                logger.info("Attempting alternative PDF bytes conversion")
-                try:
-                    images = convert_from_bytes(
-                        pdf_bytes,
-                        dpi=150,  # Lower DPI
-                        use_pdftocairo=False,
-                        strict=False
-                    )
-                    logger.info(f"Alternative bytes conversion successful: {len(images)} images")
-                except Exception as alt_bytes_err:
-                    logger.error(f"Alternative bytes conversion also failed: {str(alt_bytes_err)}")
-                    logger.error(traceback.format_exc())
-                    raise
+                print(f"[ERROR] Processing uploaded PDF failed: {str(upload_err)}")
+                raise
         else:
-            logger.error("No PDF source provided")
-            return None
-        
-        # Validate and log the output
-        if not images:
-            logger.error("PDF conversion returned empty list")
+            error_msg = "No PDF file provided (both pdf_path and pdf_file are None or invalid)"
+            logger.error(error_msg)
+            print(f"[ERROR] {error_msg}")
             return None
             
-        # Log details about the first few converted images
-        for i, img in enumerate(images[:2]):  # Log first 2 pages
-            logger.debug(f"PDF Page {i+1}: size={img.size}, mode={img.mode}")
-            
-        logger.info(f"PDF successfully processed, returning {len(images)} images")
-        return images
     except Exception as e:
-        logger.error(f"Fatal error in process_pdf: {str(e)}")
+        logger.error(f"Critical error in PDF processing: {str(e)}")
         logger.error(traceback.format_exc())
-        return None
+        print(f"[CRITICAL] PDF processing failed: {str(e)}")
+        print(traceback.format_exc())
+        
+        # Update error statistics
+        gui_stats['errors'] += 1
+        gui_stats['last_error'] = f"PDF processing error: {str(e)}"
+        gui_stats['last_error_time'] = datetime.datetime.now().strftime("%H:%M:%S")
+        
+        # Reraise for proper handling
+        raise
 
 # Function to analyze images with a prompt
 def analyze_with_prompt(image_input, prompt):
@@ -1551,6 +1564,24 @@ 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()
     
@@ -1580,6 +1611,14 @@ def main():
     def get_debug_logs(num_lines=50):
         return gui_log_handler.get_logs(last_n=num_lines)
     
+    # Function to read the full log file
+    def read_log_file():
+        try:
+            with open(latest_log, '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()
@@ -1601,6 +1640,90 @@ def main():
         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"):
+            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", 
+                        value=read_log_file(),
+                        lines=25,
+                        max_lines=30,
+                        autoscroll=False
+                    )
+                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():