Update app.py

app.py

@@ -1,6 +1,626 @@
-# Return the combined report content and all output files
+"""
+Dashboard Narrator - Powered by OpenRouter.ai
+A tool to analyze dashboard PDFs and generate comprehensive reports.
+"""
+
+# Import required libraries
+import os
+import time
+import threading
+import io
+import base64
+import json
+import requests
+from PyPDF2 import PdfReader
+from PIL import Image
+import markdown
+from weasyprint import HTML, CSS
+from weasyprint.text.fonts import FontConfiguration
+from pdf2image import convert_from_bytes
+import gradio as gr
+
+# Create a global progress tracker
+class ProgressTracker:
+    def __init__(self):
+        self.progress = 0
+        self.message = "Ready"
+        self.is_processing = False
+        self.lock = threading.Lock()
+    
+    def update(self, progress, message="Processing..."):
+        with self.lock:
+            self.progress = progress
+            self.message = message
+    
+    def get_status(self):
+        with self.lock:
+            return f"{self.message} ({self.progress:.1f}%)"
+    
+    def start_processing(self):
+        with self.lock:
+            self.is_processing = True
+            self.progress = 0
+            self.message = "Starting..."
+    
+    def end_processing(self):
+        with self.lock:
+            self.is_processing = False
+            self.progress = 100
+            self.message = "Complete"
+
+# Create a global instance
+progress_tracker = ProgressTracker()
+output_status = None
+
+# Function to update the Gradio interface with progress
+def update_progress():
+    global output_status
+    while progress_tracker.is_processing:
+        status = progress_tracker.get_status()
+        if output_status is not None:
+            output_status.update(value=status)
+        time.sleep(0.5)
+    return
+
+# OpenRouter Client for making API calls
+class OpenRouterClient:
+    def __init__(self, api_key):
+        self.api_key = api_key
+        self.base_url = "https://openrouter.ai/api/v1"
+    
+    def messages_create(self, model, messages, system=None, temperature=0.7, max_tokens=None):
+        """Send messages to the OpenRouter API and return the response"""
+        url = f"{self.base_url}/chat/completions"
+        
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+        
+        payload = {
+            "model": model,
+            "messages": messages,
+            "temperature": temperature,
+        }
+        
+        # Add system message if provided
+        if system:
+            payload["messages"].insert(0, {"role": "system", "content": system})
+        
+        # Add max_tokens if provided
+        if max_tokens:
+            payload["max_tokens"] = max_tokens
+        
+        try:
+            response = requests.post(url, headers=headers, json=payload)
+            response.raise_for_status()  # Raise an exception for HTTP errors
+            
+            result = response.json()
+            
+            # Format the response to match the expected structure
+            formatted_response = type('obj', (object,), {
+                'content': [
+                    type('obj', (object,), {
+                        'text': result['choices'][0]['message']['content']
+                    })
+                ]
+            })
+            
+            return formatted_response
+            
+        except requests.exceptions.RequestException as e:
+            print(f"API request error: {str(e)}")
+            if hasattr(e, 'response') and e.response:
+                print(f"Response: {e.response.text}")
+            raise
+
+# Supported languages configuration
+SUPPORTED_LANGUAGES = {
+    "italiano": {
+        "code": "it",
+        "name": "Italiano",
+        "report_title": "Analisi Dashboard",
+        "report_subtitle": "Report Dettagliato",
+        "date_label": "Data",
+        "system_prompt": "Sei un esperto analista di business intelligence specializzato nell'interpretazione di dashboard e dati visualizzati. Fornisci analisi in italiano approfondite e insight actionable basati sui dati forniti.",
+        "section_title": "ANALISI SEZIONE",
+        "multi_doc_title": "ANALISI DASHBOARD {index}"
+    },
+    "english": {
+        "code": "en",
+        "name": "English",
+        "report_title": "Dashboard Analysis",
+        "report_subtitle": "Detailed Report",
+        "date_label": "Date",
+        "system_prompt": "You are an expert business intelligence analyst specialized in interpreting dashboards and data visualizations. Provide in-depth analysis and actionable insights based on the data provided.",
+        "section_title": "SECTION ANALYSIS",
+        "multi_doc_title": "DASHBOARD {index} ANALYSIS"
+    },
+    "français": {
+        "code": "fr",
+        "name": "Français",
+        "report_title": "Analyse de Tableau de Bord",
+        "report_subtitle": "Rapport Détaillé",
+        "date_label": "Date",
+        "system_prompt": "Vous êtes un analyste expert en business intelligence spécialisé dans l'interprétation des tableaux de bord et des visualisations de données. Fournissez en français une analyse approfondie et des insights actionnables basés sur les données fournies.",
+        "section_title": "ANALYSE DE SECTION",
+        "multi_doc_title": "ANALYSE DU TABLEAU DE BORD {index}"
+    },
+    "español": {
+        "code": "es",
+        "name": "Español",
+        "report_title": "Análisis de Dashboard",
+        "report_subtitle": "Informe Detallado",
+        "date_label": "Fecha",
+        "system_prompt": "Eres un analista experto en inteligencia empresarial especializado en interpretar dashboards y visualizaciones de datos. Proporciona en español un análisis en profundidad e insights accionables basados en los datos proporcionados.",
+        "section_title": "ANÁLISIS DE SECCIÓN",
+        "multi_doc_title": "ANÁLISIS DEL DASHBOARD {index}"
+    },
+    "deutsch": {
+        "code": "de",
+        "name": "Deutsch",
+        "report_title": "Dashboard-Analyse",
+        "report_subtitle": "Detaillierter Bericht",
+        "date_label": "Datum",
+        "system_prompt": "Sie sind ein Experte für Business Intelligence-Analyse, der auf die Interpretation von Dashboards und Datenvisualisierungen spezialisiert ist. Bieten Sie auf Deutsch eine eingehende Analyse und umsetzbare Erkenntnisse auf Grundlage der bereitgestellten Daten.",
+        "section_title": "ABSCHNITTSANALYSE",
+        "multi_doc_title": "DASHBOARD-ANALYSE {index}"
+    }
+}
+
+# OpenRouter models
+DEFAULT_MODEL = "anthropic/claude-3.7-sonnet"
+OPENROUTER_MODELS = [
+    "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-pro-preview-03-25",
+    "microsoft/phi-4-multimodal-instruct",
+    "qwen/qwen2.5-vl-72b-instruct:free"
+]
+
+# Utility Functions
+def extract_text_from_pdf(pdf_bytes):
+    """Extract text from a PDF file."""
+    try:
+        pdf_reader = PdfReader(io.BytesIO(pdf_bytes))
+        text = ""
+        for page_num in range(len(pdf_reader.pages)):
+            extracted = pdf_reader.pages[page_num].extract_text()
+            if extracted:
+                text += extracted + "\n"
+        return text
+    except Exception as e:
+        print(f"Error extracting text from PDF: {str(e)}")
+        return ""
+
+def divide_image_vertically(image, num_sections):
+    """Divide an image vertically into sections."""
+    width, height = image.size
+    section_height = height // num_sections
+    sections = []
+    for i in range(num_sections):
+        top = i * section_height
+        bottom = height if i == num_sections - 1 else (i + 1) * section_height
+        section = image.crop((0, top, width, bottom))
+        sections.append(section)
+        print(f"Section {i+1}: size {section.width}x{section.height} pixels")
+    return sections
+
+def encode_image_with_resize(image, max_size_mb=4.5):
+    """Encode an image in base64, resizing if necessary."""
+    max_bytes = max_size_mb * 1024 * 1024
+    img_byte_arr = io.BytesIO()
+    image.save(img_byte_arr, format='PNG')
+    current_size = len(img_byte_arr.getvalue())
+    if current_size > max_bytes:
+        scale_factor = (max_bytes / current_size) ** 0.5
+        new_width = int(image.width * scale_factor)
+        new_height = int(image.height * scale_factor)
+        resized_image = image.resize((new_width, new_height), Image.LANCZOS)
+        img_byte_arr = io.BytesIO()
+        resized_image.save(img_byte_arr, format='PNG', optimize=True)
+        print(f"Image resized from {current_size/1024/1024:.2f}MB to {len(img_byte_arr.getvalue())/1024/1024:.2f}MB")
+        image = resized_image
+    else:
+        print(f"Image size acceptable: {current_size/1024/1024:.2f}MB")
+    buffer = io.BytesIO()
+    image.save(buffer, format="PNG", optimize=True)
+    return base64.b64encode(buffer.getvalue()).decode("utf-8")
+
+# Core Analysis Functions
+def analyze_dashboard_section(client, model, section_number, total_sections, image_section, full_text, language, goal_description=None):
+    """Analyze a vertical section of the dashboard in the specified language."""
+    print(f"Analyzing section {section_number}/{total_sections} in {language['name']} using {model}...")
+    try:
+        encoded_image = encode_image_with_resize(image_section)
+    except Exception as e:
+        print(f"Error encoding section {section_number}: {str(e)}")
+        return f"Error analyzing section {section_number}: {str(e)}"
+    
+    section_prompt = f"""
+        Act as a senior data analyst examining this dashboard section for Customer Experience purpose.\n
+    Your analysis will be shared with top executives to inform about Customer Experience improvements and customer satisfaction level.\n
+    # Dashboard Analysis - Section {section_number} of {total_sections}\n
+    You are analyzing section {section_number} of {total_sections} of a long vertical dashboard. This is part of a broader analysis.\n
+    {f"The analysis objective is: {goal_description}" if goal_description else ""}\n\n
+    For this specific section:\n
+    1. Describe what these visualizations show, including their type (e.g., bar chart, line graph) and the data they represent\n
+    2. Quantitatively analyze the data, noting specific values, percentages, and numeric trends\n
+    3. Identify significant patterns, anomalies, or outliers visible in the data\n
+    4. Provide 2-3 actionable insights based on this analysis, explaining their business implications\n
+    5. Suggest possible reasons for any notable trends or unexpected findings\n
+    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]}
+    
+    # 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.
+    """
+    
+    try:
+        response = client.messages_create(
+            model=model,
+            messages=[{"role": "user", "content": section_prompt}],
+            system=language['system_prompt'],
+            temperature=0.1,
+            max_tokens=10000
+        )
+        return response.content[0].text
+    except Exception as e:
+        print(f"Error analyzing section {section_number}: {str(e)}")
+        return f"Error analyzing section {section_number}: {str(e)}"
+
+def create_comprehensive_report(client, model, section_analyses, full_text, language, goal_description=None):
+    """Create a unified comprehensive report based on individual section analyses."""
+    print(f"Generating final comprehensive report in {language['name']} using {model}...")
+    comprehensive_prompt = f"""
+    # Comprehensive Dashboard Analysis Request
+    You have analyzed a long vertical dashboard in multiple sections. Now you need to create a unified and coherent report based on all the partial analyses.\n
+    {f"The analysis objective is: {goal_description}" if goal_description else ""}\n\n
+    Here are the analyses of the individual dashboard sections:\n
+    {section_analyses}\n\n
+    Based on these partial analyses, generate a professional, structured, and coherent report that includes:\n
+    1. Executive Summary - Include key metrics, major findings, and critical recommendations (limit to 1 page equivalent)\n
+    2. Dashboard Performance Overview - Add a section that evaluates the overall health metrics before diving into categories\n
+    3 Detailed Analysis by Category - Keep this, it's essential\n
+    4 Trend Analysis - Broaden from just temporal to include cross-category patterns\n
+    5 Critical Issues and Opportunities - Combine anomalies with positive outliers to provide balanced insights\n
+    6 Strategic Implications and Recommendations - Consolidate your insights and recommendations into a single, stronger section\n
+    7 Implementation Roadmap - Convert your conclusions into a prioritized action plan with timeframes\n
+    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]}
+    """
+    try:
+        response = client.messages_create(
+            model=model,
+            messages=[{"role": "user", "content": comprehensive_prompt}],
+            system=language['system_prompt'],
+            temperature=0.1,
+            max_tokens=10000
+        )
+        return response.content[0].text
+    except Exception as e:
+        print(f"Error creating comprehensive report: {str(e)}")
+        return f"Error creating comprehensive report: {str(e)}"
+
+def create_multi_dashboard_comparative_report(client, model, individual_reports, language, goal_description=None):
+    """Create a comparative report analyzing multiple dashboards together."""
+    print(f"Generating comparative report for multiple dashboards in {language['name']} using {model}...")
+    comparative_prompt = f"""
+    # Multi-Dashboard Comparative Analysis Request
+    You have analyzed multiple dashboards individually. Now you need to create a comparative analysis report that identifies patterns, similarities, differences, and insights across all dashboards.
+    {f"The analysis objective is: {goal_description}" if goal_description else ""}
+    Here are the analyses of the individual dashboards:
+    {individual_reports}
+    Based on these individual analyses, generate a professional, structured comparative report that includes:
+    1. Executive Overview of All Dashboards
+    2. Comparative Analysis of Key Metrics
+    3. Cross-Dashboard Patterns and Trends
+    4. Notable Differences Between Dashboards
+    5. Integrated Insights from All Sources
+    6. Comprehensive Strategic Recommendations
+    7. Suggestions for Cross-Dashboard Monitoring Improvements
+    8. Conclusions and Integrated Next Steps
+    Integrate information from all dashboards to create a coherent comparative report.
+    """
+    try:
+        response = client.messages_create(
+            model=model,
+            messages=[{"role": "user", "content": comparative_prompt}],
+            system=language['system_prompt'],
+            temperature=0.1,
+            max_tokens=12000
+        )
+        return response.content[0].text
+    except Exception as e:
+        print(f"Error creating comparative report: {str(e)}")
+        return f"Error creating comparative report: {str(e)}"
+
+def markdown_to_pdf(markdown_content, output_filename, language):
+    """Convert Markdown content to a well-formatted PDF."""
+    print(f"Converting Markdown report to PDF in {language['name']}...")
+    css = CSS(string='''
+        @page { margin: 1.5cm; }
+        body { font-family: Arial, sans-serif; line-height: 1.5; font-size: 11pt; }
+        h1 { color: #2c3e50; font-size: 22pt; margin-top: 1cm; margin-bottom: 0.5cm; page-break-after: avoid; }
+        h2 { color: #3498db; font-size: 16pt; margin-top: 0.8cm; margin-bottom: 0.3cm; page-break-after: avoid; }
+        p { margin-bottom: 0.3cm; text-align: justify; }
+    ''')
+    today = time.strftime("%d/%m/%Y")
+    cover_page = f"""
+    <div style="text-align: center; height: 100vh; display: flex; flex-direction: column; justify-content: center; align-items: center;">
+        <h1 style="font-size: 26pt; color: #2c3e50;">{language['report_title']}</h1>
+        <h2 style="font-size: 14pt; color: #7f8c8d;">{language['report_subtitle']}</h2>
+        <p style="font-size: 12pt; color: #7f8c8d;">{language['date_label']}: {today}</p>
+    </div>
+    <div style="page-break-after: always;"></div>
+    """
+    html_content = markdown.markdown(markdown_content, extensions=['tables', 'fenced_code'])
+    full_html = f"""
+    <!DOCTYPE html>
+    <html lang="{language['code']}">
+    <head><meta charset="UTF-8"><title>{language['report_title']}</title></head>
+    <body>{cover_page}{html_content}</body>
+    </html>
+    """
+    font_config = FontConfiguration()
+    HTML(string=full_html).write_pdf(output_filename, stylesheets=[css], font_config=font_config)
+    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."""
+    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
+    dashboard_progress_step = (100 / total_dashboards) if total_dashboards > 0 else 100
+    
+    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.")
+    else:
+        print(f"✅ Extracted {len(full_text)} characters of text from PDF.")
+    
+    progress_tracker.update(dashboard_progress_base + dashboard_progress_step * 0.2, f"🖼️ Converting dashboard{dashboard_marker} to images...")
+    print("🖼️ Converting PDF to images...")
+    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]
+        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...")
+        print(f"Dividing image into {num_sections} vertical sections...")
+        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)}")
+        return None, f"Error: {str(e)}"
+    
+    section_analyses = []
+    section_progress_step = dashboard_progress_step * 0.4 / len(image_sections)
+    
+    for i, section in enumerate(image_sections):
+        section_progress = dashboard_progress_base + dashboard_progress_step * 0.3 + section_progress_step * i
+        progress_tracker.update(section_progress, f"Analyzing section {i+1}/{len(image_sections)} of dashboard{dashboard_marker}...")
+        
+        print(f"\n{'='*50}")
+        print(f"Processing section {i+1}/{len(image_sections)}...")
+        section_result = analyze_dashboard_section(
+            client, 
+            model,
+            i+1, 
+            len(image_sections), 
+            section, 
+            full_text, 
+            language,
+            goal_description
+        )
+        if section_result:
+            section_analyses.append(f"\n## {language['section_title']} {i+1}\n{section_result}")
+            print(f"✅ Analysis of section {i+1} completed.")
+        else:
+            section_analyses.append(f"\n## {language['section_title']} {i+1}\nAnalysis not available for this section.")
+            print(f"⚠️ Analysis of section {i+1} not available.")
+    
+    progress_tracker.update(dashboard_progress_base + dashboard_progress_step * 0.7, f"Generating final report for dashboard{dashboard_marker}...")
+    print("\n" + "="*50)
+    print(f"All section analyses completed. Generating report...")
+    combined_sections = "\n".join(section_analyses)
+    
+    # If dashboard index is provided, add a header for the dashboard
+    if dashboard_index is not None:
+        dashboard_header = f"# {language['multi_doc_title'].format(index=dashboard_index)}\n\n"
+        combined_sections = dashboard_header + combined_sections
+    
+    final_report = create_comprehensive_report(client, model, combined_sections, full_text, language, goal_description)
+    
+    # If dashboard index is provided, prepend it to the report
+    if dashboard_index is not None and dashboard_index > 1:
+        # Only add header if it doesn't already exist (might have been added by Claude)
+        if not final_report.startswith(f"# {language['multi_doc_title'].format(index=dashboard_index)}"):
+            final_report = f"# {language['multi_doc_title'].format(index=dashboard_index)}\n\n{final_report}"
+    
+    progress_tracker.update(dashboard_progress_base + dashboard_progress_step * 0.9, f"Finalizing dashboard{dashboard_marker} analysis...")
+    return final_report, combined_sections
+
+def get_available_models(api_key):
+    """Get available models from OpenRouter API."""
+    try:
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+        response = requests.get("https://openrouter.ai/api/v1/models", headers=headers)
+        
+        if response.status_code == 200:
+            models_data = response.json()
+            available_models = [model["id"] for model in models_data.get("data", [])]
+            
+            # First add our preferred models at the top if they're available
+            sorted_models = [model for model in OPENROUTER_MODELS if model in available_models]
+            
+            # Then add any additional models not in our predefined list
+            additional_models = [model for model in available_models if model not in OPENROUTER_MODELS]
+            additional_models.sort()
+            
+            all_models = ["custom"] + sorted_models + additional_models
+            return all_models
+        else:
+            print(f"Error fetching models: {response.status_code}")
+            return ["custom"] + OPENROUTER_MODELS
+    except Exception as e:
+        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."""
+    # Start progress tracking
+    progress_tracker.start_processing()
+    progress_tracker.total_dashboards = len(pdf_files)
+    
+    # Step 1: Initialize language settings and API client
+    progress_tracker.update(1, "Initializing analysis...")
+    language = None
+    for lang_key, lang_data in SUPPORTED_LANGUAGES.items():
+        if lang_data['code'] == language_code:
+            language = lang_data
+            break
+    if not language:
+        print(f"⚠️ Language '{language_code}' not supported. Using Italian as fallback.")
+        language = SUPPORTED_LANGUAGES['italiano']
+    print(f"🌐 Selected language: {language['name']}")
+    
+    if not api_key:
+        progress_tracker.update(100, "⚠️ Error: API key not provided.")
+        progress_tracker.end_processing()
+        print("⚠️ Error: API key not provided.")
+        return None, None, "Error: API key not provided."
+    
+    try:
+        client = OpenRouterClient(api_key=api_key)
+        print("✅ OpenRouter client initialized successfully.")
+    except Exception as e:
+        progress_tracker.update(100, f"❌ Error initializing client: {str(e)}")
+        progress_tracker.end_processing()
+        print(f"❌ Error initializing client: {str(e)}")
+        return None, None, f"Error: {str(e)}"
+    
+    # Determine which model to use
+    model = custom_model if model_name == "custom" and custom_model else model_name
+    print(f"🤖 Using model: {model}")
+    
+    # Step 2: Process each dashboard individually
+    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)}...")
+        print(f"\n{'#'*60}")
+        print(f"Processing dashboard {i+1}/{len(pdf_files)}...")
+        
+        report, analysis = analyze_vertical_dashboard(
+            client=client,
+            model=model,
+            pdf_bytes=pdf_bytes,
+            language=language,
+            goal_description=goal_description,
+            num_sections=num_sections,
+            dashboard_index=i+1
+        )
+        
+        if report:
+            individual_reports.append(report)
+            individual_analyses.append(analysis)
+            print(f"✅ Analysis of dashboard {i+1} completed.")
+        else:
+            print(f"❌ Analysis of dashboard {i+1} failed.")
+    
+    # For Hugging Face Space: use tmp directory for file output
+    tmp_dir = "/tmp"
+    if not os.path.exists(tmp_dir):
+        os.makedirs(tmp_dir, exist_ok=True)
+    
+    # Step 3: Generate output files
+    progress_tracker.update(80, "Generating output files...")
+    timestamp = time.strftime("%Y%m%d_%H%M%S")
+    output_files = []
+    
+    # Create individual report files
+    for i, report in enumerate(individual_reports):
+        file_progress = 80 + (i / len(individual_reports) * 10)  # 10% for creating files
+        progress_tracker.update(file_progress, f"Creating files for dashboard {i+1}...")
+        
+        md_filename = os.path.join(tmp_dir, f"dashboard_{i+1}_{language['code']}_{timestamp}.md")
+        pdf_filename = os.path.join(tmp_dir, f"dashboard_{i+1}_{language['code']}_{timestamp}.pdf")
+        
+        with open(md_filename, 'w', encoding='utf-8') as f:
+            f.write(report)
+        output_files.append(md_filename)
+        
+        try:
+            pdf_path = markdown_to_pdf(report, pdf_filename, language)
+            output_files.append(pdf_filename)
+        except Exception as e:
+            print(f"⚠️ Error converting dashboard {i+1} to PDF: {str(e)}")
+    
+    # If there are multiple dashboards, create a comparative report
+    comparative_report = None
+    if len(individual_reports) > 1:
+        progress_tracker.update(90, "Creating comparative analysis...")
+        print("\n" + "#"*60)
+        print("Creating comparative analysis of all dashboards...")
+        
+        # Combined report content
+        all_reports_content = "\n\n".join(individual_reports)
+        
+        # Generate comparative analysis
+        comparative_report = create_multi_dashboard_comparative_report(
+            client=client,
+            model=model,
+            individual_reports=all_reports_content,
+            language=language,
+            goal_description=goal_description
+        )
+        
+        # Save comparative report
+        progress_tracker.update(95, "Saving comparative analysis files...")
+        comparative_md = os.path.join(tmp_dir, f"comparative_analysis_{language['code']}_{timestamp}.md")
+        comparative_pdf = os.path.join(tmp_dir, f"comparative_analysis_{language['code']}_{timestamp}.pdf")
+        
+        with open(comparative_md, 'w', encoding='utf-8') as f:
+            f.write(comparative_report)
+        output_files.append(comparative_md)
+        
+        try:
+            pdf_path = markdown_to_pdf(comparative_report, comparative_pdf, language)
+            output_files.append(comparative_pdf)
+        except Exception as e:
+            print(f"⚠️ Error converting comparative report to PDF: {str(e)}")
+    
+    # Complete progress tracking
+    progress_tracker.update(100, "✅ Analysis completed successfully!")
+    progress_tracker.end_processing()
+    
+   # Return the combined report content and all output files
     combined_content = "\n\n---\n\n".join(individual_reports)
-    if len(individual_reports) > 1 and 'comparative_report' in locals():
+    if len(individual_reports) > 1 and comparative_report:
         combined_content += f"\n\n{'='*80}\n\n# COMPARATIVE ANALYSIS\n\n{comparative_report}"
     
     return combined_content, output_files, "✅ Analysis completed successfully!"
@@ -162,4 +782,5 @@ with gr.Blocks(title="Dashboard Narrator - Powered by OpenRouter.ai", theme=gr.t
 
 # Launch the app
 if __name__ == "__main__":
+    demo.launch()
     demo.launch()