Update app.py

app.py

@@ -1,6 +1,6 @@
 """
 Dashboard Narrator - Powered by OpenRouter.ai
-A tool to analyze dashboard PDFs and generate comprehensive reports.
+A tool to analyze dashboard PDFs and images and generate comprehensive reports.
 """
 
 # Import required libraries
@@ -168,15 +168,17 @@ SUPPORTED_LANGUAGES = {
     }
 }
 
-# OpenRouter models
-DEFAULT_MODEL = "anthropic/claude-3.7-sonnet"
+# OpenRouter models - Updated with new models
+DEFAULT_MODEL = "anthropic/claude-sonnet-4"
 OPENROUTER_MODELS = [
+    "anthropic/claude-sonnet-4",
     "anthropic/claude-3.7-sonnet",
     "openai/gpt-4.1",
     "openai/o4-mini-high",
     "openai/gpt-4.1-mini",
-    "moonshotai/kimi-vl-a3b-thinking:free",
+    "google/gemini-2.5-flash-preview-05-20",
     "google/gemini-2.5-pro-preview-03-25",
+    "moonshotai/kimi-vl-a3b-thinking:free",
     "microsoft/phi-4-multimodal-instruct",
     "qwen/qwen2.5-vl-72b-instruct:free",
     "openrouter/optimus-alpha"
@@ -197,6 +199,39 @@ def extract_text_from_pdf(pdf_bytes):
         print(f"Error extracting text from PDF: {str(e)}")
         return ""
 
+def get_file_type(file_path):
+    """Determine the file type based on file extension."""
+    if file_path.lower().endswith('.pdf'):
+        return 'pdf'
+    elif file_path.lower().endswith(('.png', '.jpg', '.jpeg')):
+        return 'image'
+    else:
+        return 'unknown'
+
+def load_image_from_file(file_path):
+    """Load an image from file path."""
+    try:
+        image = Image.open(file_path)
+        # Convert to RGB if necessary
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+        return image
+    except Exception as e:
+        print(f"Error loading image from {file_path}: {str(e)}")
+        return None
+
+def load_image_from_bytes(image_bytes):
+    """Load an image from bytes."""
+    try:
+        image = Image.open(io.BytesIO(image_bytes))
+        # Convert to RGB if necessary
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+        return image
+    except Exception as e:
+        print(f"Error loading image from bytes: {str(e)}")
+        return None
+
 def divide_image_vertically(image, num_sections):
     """Divide an image vertically into sections."""
     width, height = image.size
@@ -256,17 +291,31 @@ def analyze_dashboard_section(client, model, section_number, total_sections, ima
     Focus exclusively on the visible section. Don't reference or speculate about unseen dashboard elements.\n
     Answer completely in {language['name']}.\n\n
     # Text extracted from the complete dashboard:\n
-    {full_text[:10000]}
+    {full_text[:10000] if full_text else "No text available for this image."}
     
     # Image of this dashboard section:
     [BASE64 IMAGE: {encoded_image[:20]}...] 
     This is a dashboard visualization showing various metrics and charts. Please analyze the content visible in this image.
     """
     
+    # Create message with image for vision models
+    message_content = [
+        {
+            "type": "text",
+            "text": section_prompt
+        },
+        {
+            "type": "image_url",
+            "image_url": {
+                "url": f"data:image/png;base64,{encoded_image}"
+            }
+        }
+    ]
+    
     try:
         response = client.messages_create(
             model=model,
-            messages=[{"role": "user", "content": section_prompt}],
+            messages=[{"role": "user", "content": message_content}],
             system=language['system_prompt'],
             temperature=0.1,
             max_tokens=10000
@@ -296,7 +345,7 @@ def create_comprehensive_report(client, model, section_analyses, full_text, lang
     8 Appendix: Monitoring Improvements - Move the monitoring suggestions to an appendix unless they're a primary focus\n\n
     Integrate information from all sections to create a coherent and complete report.\n\n
     # Text extracted from the complete dashboard:\n
-    {full_text[:10000]}
+    {full_text[:10000] if full_text else "No text available for this image."}
     """
     try:
         response = client.messages_create(
@@ -376,8 +425,8 @@ def markdown_to_pdf(markdown_content, output_filename, language):
     print(f"PDF created successfully: {output_filename}")
     return output_filename
 
-def analyze_vertical_dashboard(client, model, pdf_bytes, language, goal_description=None, num_sections=4, dashboard_index=None):
-    """Analyze a vertical dashboard by dividing it into sections."""
+def analyze_vertical_dashboard(client, model, file_data, file_type, language, goal_description=None, num_sections=4, dashboard_index=None):
+    """Analyze a vertical dashboard by dividing it into sections. Supports both PDF and image files."""
     dashboard_marker = f" {dashboard_index}" if dashboard_index is not None else ""
     total_dashboards = progress_tracker.total_dashboards if hasattr(progress_tracker, 'total_dashboards') else 1
     dashboard_progress_base = ((dashboard_index - 1) / total_dashboards * 100) if dashboard_index is not None else 0
@@ -386,23 +435,40 @@ def analyze_vertical_dashboard(client, model, pdf_bytes, language, goal_descript
     progress_tracker.update(dashboard_progress_base, f"🖼️ Analyzing dashboard{dashboard_marker}...")
     print(f"🖼️ Analyzing dashboard{dashboard_marker}...")
     
-    progress_tracker.update(dashboard_progress_base + dashboard_progress_step * 0.1, f"📄 Extracting text from dashboard{dashboard_marker}...")
-    print(f"📄 Extracting full text from PDF...")
-    full_text = extract_text_from_pdf(pdf_bytes)
-    if not full_text or len(full_text.strip()) < 100:
-        print("⚠️ Limited text extracted from PDF. Analysis will rely primarily on images.")
+    # Extract text if it's a PDF
+    full_text = ""
+    if file_type == 'pdf':
+        progress_tracker.update(dashboard_progress_base + dashboard_progress_step * 0.1, f"📄 Extracting text from dashboard{dashboard_marker}...")
+        print(f"📄 Extracting full text from PDF...")
+        full_text = extract_text_from_pdf(file_data)
+        if not full_text or len(full_text.strip()) < 100:
+            print("⚠️ Limited text extracted from PDF. Analysis will rely primarily on images.")
+        else:
+            print(f"✅ Extracted {len(full_text)} characters of text from PDF.")
     else:
-        print(f"✅ Extracted {len(full_text)} characters of text from PDF.")
+        print("📄 Image file detected - no text extraction needed.")
     
+    # Convert to image(s)
     progress_tracker.update(dashboard_progress_base + dashboard_progress_step * 0.2, f"🖼️ Converting dashboard{dashboard_marker} to images...")
-    print("🖼️ Converting PDF to images...")
+    print("🖼️ Processing image...")
+    
     try:
-        pdf_images = convert_from_bytes(pdf_bytes, dpi=150)
-        if not pdf_images:
-            print("❌ Unable to convert PDF to images.")
-            return None, "Error: Unable to convert PDF to images."
-        print(f"✅ PDF converted to {len(pdf_images)} image pages.")
-        main_image = pdf_images[0]
+        if file_type == 'pdf':
+            # Convert PDF to images
+            pdf_images = convert_from_bytes(file_data, dpi=150)
+            if not pdf_images:
+                print("❌ Unable to convert PDF to images.")
+                return None, "Error: Unable to convert PDF to images."
+            print(f"✅ PDF converted to {len(pdf_images)} image pages.")
+            main_image = pdf_images[0]
+        else:
+            # Load image directly
+            main_image = load_image_from_bytes(file_data)
+            if main_image is None:
+                print("❌ Unable to load image.")
+                return None, "Error: Unable to load image."
+            print(f"✅ Image loaded successfully.")
+        
         print(f"Main image size: {main_image.width}x{main_image.height} pixels")
         
         progress_tracker.update(dashboard_progress_base + dashboard_progress_step * 0.3, f"Dividing dashboard{dashboard_marker} into {num_sections} sections...")
@@ -410,7 +476,7 @@ def analyze_vertical_dashboard(client, model, pdf_bytes, language, goal_descript
         image_sections = divide_image_vertically(main_image, num_sections)
         print(f"✅ Image divided into {len(image_sections)} sections.")
     except Exception as e:
-        print(f"❌ Error converting or dividing PDF: {str(e)}")
+        print(f"❌ Error processing image: {str(e)}")
         return None, f"Error: {str(e)}"
     
     section_analyses = []
@@ -490,11 +556,11 @@ def get_available_models(api_key):
         print(f"Error fetching models: {str(e)}")
         return ["custom"] + OPENROUTER_MODELS
 
-def process_multiple_dashboards(api_key, pdf_files, language_code="it", goal_description=None, num_sections=4, model_name=DEFAULT_MODEL, custom_model=None):
-    """Process multiple dashboard PDFs and create individual and comparative reports."""
+def process_multiple_dashboards(api_key, files, language_code="it", goal_description=None, num_sections=4, model_name=DEFAULT_MODEL, custom_model=None):
+    """Process multiple dashboard files (PDF/images) and create individual and comparative reports."""
     # Start progress tracking
     progress_tracker.start_processing()
-    progress_tracker.total_dashboards = len(pdf_files)
+    progress_tracker.total_dashboards = len(files)
     
     # Step 1: Initialize language settings and API client
     progress_tracker.update(1, "Initializing analysis...")
@@ -531,16 +597,17 @@ def process_multiple_dashboards(api_key, pdf_files, language_code="it", goal_des
     individual_reports = []
     individual_analyses = []
     
-    for i, pdf_bytes in enumerate(pdf_files):
-        dashboard_progress_base = (i / len(pdf_files) * 80)  # 80% of progress for dashboard analysis
-        progress_tracker.update(dashboard_progress_base, f"Processing dashboard {i+1}/{len(pdf_files)}...")
+    for i, (file_data, file_type) in enumerate(files):
+        dashboard_progress_base = (i / len(files) * 80)  # 80% of progress for dashboard analysis
+        progress_tracker.update(dashboard_progress_base, f"Processing dashboard {i+1}/{len(files)}...")
         print(f"\n{'#'*60}")
-        print(f"Processing dashboard {i+1}/{len(pdf_files)}...")
+        print(f"Processing dashboard {i+1}/{len(files)} (Type: {file_type})...")
         
         report, analysis = analyze_vertical_dashboard(
             client=client,
             model=model,
-            pdf_bytes=pdf_bytes,
+            file_data=file_data,
+            file_type=file_type,
             language=language,
             goal_description=goal_description,
             num_sections=num_sections,
@@ -628,8 +695,8 @@ def process_multiple_dashboards(api_key, pdf_files, language_code="it", goal_des
     return combined_content, output_files, "✅ Analysis completed successfully!"
 
 # Wrapper function for Gradio interface
-def process_dashboard(api_key, pdf_files, language_name, goal_description=None, num_sections=4, model_name=DEFAULT_MODEL, custom_model=None):
-    """Process dashboard PDFs and generate reports (wrapper function for Gradio interface)."""
+def process_dashboard(api_key, files, language_name, goal_description=None, num_sections=4, model_name=DEFAULT_MODEL, custom_model=None):
+    """Process dashboard files (PDF/images) and generate reports (wrapper function for Gradio interface)."""
     # Start a thread to update progress
     progress_thread = threading.Thread(target=update_progress)
     progress_thread.daemon = True
@@ -642,31 +709,58 @@ def process_dashboard(api_key, pdf_files, language_name, goal_description=None,
             language_code = lang_data['code']
             break
     
-    # Get the PDF file bytes
-    pdf_bytes_list = []
-    if pdf_files is not None:
-        for pdf_file in pdf_files:
-            if isinstance(pdf_file, dict) and 'name' in pdf_file:
-                # Handle newer Gradio File component format
-                with open(pdf_file['name'], 'rb') as f:
-                    pdf_bytes_list.append(f.read())
-            elif isinstance(pdf_file, str):
-                # Handle older Gradio File component format
-                with open(pdf_file, 'rb') as f:
-                    pdf_bytes_list.append(f.read())
-            else:
-                # Just try to handle whatever format we got
-                try:
-                    if hasattr(pdf_file, 'read'):
-                        pdf_bytes_list.append(pdf_file.read())
-                except Exception as e:
-                    print(f"Error reading PDF file: {str(e)}")
+    # Process the uploaded files
+    processed_files = []
+    if files is not None:
+        for file in files:
+            try:
+                # Handle different Gradio file formats
+                file_path = None
+                if isinstance(file, dict) and 'name' in file:
+                    # Newer Gradio File component format
+                    file_path = file['name']
+                elif isinstance(file, str):
+                    # Older Gradio File component format
+                    file_path = file
+                else:
+                    # Try to get the path from the file object
+                    if hasattr(file, 'name'):
+                        file_path = file.name
+                    elif hasattr(file, 'path'):
+                        file_path = file.path
+                
+                if file_path:
+                    # Determine file type
+                    file_type = get_file_type(file_path)
+                    
+                    if file_type == 'unknown':
+                        print(f"⚠️ Unsupported file type for {file_path}")
+                        continue
+                    
+                    # Read file data
+                    with open(file_path, 'rb') as f:
+                        file_data = f.read()
+                    
+                    processed_files.append((file_data, file_type))
+                    print(f"✅ Processed {file_path} as {file_type}")
+                else:
+                    print(f"⚠️ Could not determine file path for uploaded file")
+                    
+            except Exception as e:
+                print(f"❌ Error processing uploaded file: {str(e)}")
+                continue
+    
+    if not processed_files:
+        error_message = "No valid files were uploaded or processed."
+        progress_tracker.update(100, error_message)
+        progress_tracker.end_processing()
+        return None, None, error_message
     
     # Call the actual processing function
     try:
         combined_content, output_files, status = process_multiple_dashboards(
             api_key=api_key,
-            pdf_files=pdf_bytes_list,
+            files=processed_files,
             language_code=language_code,
             goal_description=goal_description,
             num_sections=num_sections,
@@ -703,10 +797,14 @@ with gr.Blocks(title="Dashboard Narrator - Powered by OpenRouter.ai", theme=gr.t
     gr.Markdown("""
     # 📊 Dashboard Narrator - Powered by OpenRouter.ai
     Unlock the hidden stories in your dashboards!<br>
-    Dashboard Narrator leverages advanced AI models through OpenRouter.ai to dissect your PDF reports,<br> 
+    Dashboard Narrator leverages advanced AI models through OpenRouter.ai to dissect your PDF reports and images,<br> 
     analyze each segment with expert precision, and craft comprehensive insights in your preferred language.<br><br>
     Turn complex data visualizations into clear, strategic recommendations and uncover trends you might have missed.<br>
     From executive summaries to detailed breakdowns, get the full narrative behind your numbers in just a few clicks.<br><br>
+    **✨ New Features:**
+    - Support for PNG and JPG image analysis
+    - Enhanced with Claude Sonnet 4 and Gemini 2.5 Flash models
+    - Multi-format dashboard analysis capabilities
     """)
     with gr.Row():
         with gr.Column(scale=1):
@@ -744,9 +842,9 @@ with gr.Blocks(title="Dashboard Narrator - Powered by OpenRouter.ai", theme=gr.t
                 placeholder="E.g., Analyze Q1 2024 sales KPIs..."
             )
             
-            pdf_files = gr.File(
-                label="Upload Dashboards (PDF)", 
-                file_types=[".pdf"], 
+            files = gr.File(
+                label="Upload Dashboards (PDF, PNG, JPG)", 
+                file_types=[".pdf", ".png", ".jpg", ".jpeg"], 
                 file_count="multiple"
             )
             
@@ -778,7 +876,7 @@ with gr.Blocks(title="Dashboard Narrator - Powered by OpenRouter.ai", theme=gr.t
     # Handle analyze button
     analyze_btn.click(
         fn=process_dashboard,
-        inputs=[api_key, pdf_files, language, goal, num_sections, model_choice, custom_model],
+        inputs=[api_key, files, language, goal, num_sections, model_choice, custom_model],
         outputs=[output_md, output_files, output_status]
     )