Update app.py

app.py

@@ -18,6 +18,8 @@ from weasyprint import HTML, CSS
 from weasyprint.text.fonts import FontConfiguration
 from pdf2image import convert_from_bytes
 import gradio as gr
+import tempfile
+import shutil
 
 # Create a global progress tracker
 class ProgressTracker:
@@ -556,6 +558,78 @@ def get_available_models(api_key):
         print(f"Error fetching models: {str(e)}")
         return ["custom"] + OPENROUTER_MODELS
 
+# FIXED: Improved file handling for Gradio compatibility
+def create_output_files(individual_reports, comparative_report, language, timestamp):
+    """Create output files with proper Gradio compatibility."""
+    output_files = []
+    
+    try:
+        # Create a temporary directory that Gradio can access
+        temp_dir = tempfile.mkdtemp()
+        print(f"Created temporary directory: {temp_dir}")
+        
+        # Create individual report files
+        for i, report in enumerate(individual_reports):
+            if report and report.strip():  # Only create files for valid reports
+                # Create markdown file
+                md_filename = os.path.join(temp_dir, f"dashboard_{i+1}_{language['code']}_{timestamp}.md")
+                try:
+                    with open(md_filename, 'w', encoding='utf-8') as f:
+                        f.write(report)
+                    if os.path.exists(md_filename) and os.path.getsize(md_filename) > 0:
+                        output_files.append(md_filename)
+                        print(f"✅ Created markdown file: {md_filename}")
+                    else:
+                        print(f"⚠️ Failed to create valid markdown file for dashboard {i+1}")
+                except Exception as e:
+                    print(f"❌ Error creating markdown file for dashboard {i+1}: {str(e)}")
+                
+                # Create PDF file
+                pdf_filename = os.path.join(temp_dir, f"dashboard_{i+1}_{language['code']}_{timestamp}.pdf")
+                try:
+                    pdf_path = markdown_to_pdf(report, pdf_filename, language)
+                    if os.path.exists(pdf_filename) and os.path.getsize(pdf_filename) > 0:
+                        output_files.append(pdf_filename)
+                        print(f"✅ Created PDF file: {pdf_filename}")
+                    else:
+                        print(f"⚠️ Failed to create valid PDF file for dashboard {i+1}")
+                except Exception as e:
+                    print(f"❌ Error creating PDF file for dashboard {i+1}: {str(e)}")
+        
+        # Create comparative report if available
+        if comparative_report and comparative_report.strip():
+            # Create comparative markdown file
+            comparative_md = os.path.join(temp_dir, f"comparative_analysis_{language['code']}_{timestamp}.md")
+            try:
+                with open(comparative_md, 'w', encoding='utf-8') as f:
+                    f.write(comparative_report)
+                if os.path.exists(comparative_md) and os.path.getsize(comparative_md) > 0:
+                    output_files.append(comparative_md)
+                    print(f"✅ Created comparative markdown file: {comparative_md}")
+                else:
+                    print(f"⚠️ Failed to create valid comparative markdown file")
+            except Exception as e:
+                print(f"❌ Error creating comparative markdown file: {str(e)}")
+            
+            # Create comparative PDF file
+            comparative_pdf = os.path.join(temp_dir, f"comparative_analysis_{language['code']}_{timestamp}.pdf")
+            try:
+                pdf_path = markdown_to_pdf(comparative_report, comparative_pdf, language)
+                if os.path.exists(comparative_pdf) and os.path.getsize(comparative_pdf) > 0:
+                    output_files.append(comparative_pdf)
+                    print(f"✅ Created comparative PDF file: {comparative_pdf}")
+                else:
+                    print(f"⚠️ Failed to create valid comparative PDF file")
+            except Exception as e:
+                print(f"❌ Error creating comparative PDF file: {str(e)}")
+        
+        print(f"Total output files created: {len(output_files)}")
+        return output_files
+        
+    except Exception as e:
+        print(f"❌ Error in create_output_files: {str(e)}")
+        return []
+
 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
@@ -621,38 +695,10 @@ def process_multiple_dashboards(api_key, files, language_code="it", goal_descrip
         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
+    # Step 3: Generate comparative report if multiple dashboards
     comparative_report = None
     if len(individual_reports) > 1:
-        progress_tracker.update(90, "Creating comparative analysis...")
+        progress_tracker.update(80, "Creating comparative analysis...")
         print("\n" + "#"*60)
         print("Creating comparative analysis of all dashboards...")
         
@@ -667,34 +713,39 @@ def process_multiple_dashboards(api_key, files, language_code="it", goal_descrip
             language=language,
             goal_description=goal_description
         )
+    
+    # Step 4: Create output files with improved handling
+    progress_tracker.update(90, "Creating output files...")
+    timestamp = time.strftime("%Y%m%d_%H%M%S")
+    
+    try:
+        output_files = create_output_files(individual_reports, comparative_report, language, timestamp)
         
-        # 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)
+        if not output_files:
+            error_msg = "No output files were created successfully."
+            progress_tracker.update(100, f"⚠️ {error_msg}")
+            progress_tracker.end_processing()
+            return None, None, error_msg
         
-        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)}")
+    except Exception as e:
+        error_msg = f"Error creating output files: {str(e)}"
+        print(f"❌ {error_msg}")
+        progress_tracker.update(100, f"❌ {error_msg}")
+        progress_tracker.end_processing()
+        return None, None, error_msg
     
     # Complete progress tracking
     progress_tracker.update(100, "✅ Analysis completed successfully!")
     progress_tracker.end_processing()
     
-   # Return the combined report content and all output files
+    # 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:
         combined_content += f"\n\n{'='*80}\n\n# COMPARATIVE ANALYSIS\n\n{comparative_report}"
     
     return combined_content, output_files, "✅ Analysis completed successfully!"
 
-# Wrapper function for Gradio interface
+# FIXED: Improved 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
@@ -709,53 +760,86 @@ def process_dashboard(api_key, files, language_name, goal_description=None, num_
             language_code = lang_data['code']
             break
     
-    # Process the uploaded files
+    # Validate inputs
+    if not api_key or not api_key.strip():
+        error_message = "API key is required."
+        progress_tracker.update(100, f"❌ {error_message}")
+        progress_tracker.end_processing()
+        return None, None, error_message
+    
+    if not files or len(files) == 0:
+        error_message = "No files uploaded."
+        progress_tracker.update(100, f"❌ {error_message}")
+        progress_tracker.end_processing()
+        return None, None, error_message
+    
+    # Process the uploaded files with improved handling
     processed_files = []
     if files is not None:
-        for file in files:
+        for i, file in enumerate(files):
             try:
-                # Handle different Gradio file formats
+                # Handle different Gradio file formats more robustly
                 file_path = None
-                if isinstance(file, dict) and 'name' in file:
-                    # Newer Gradio File component format
-                    file_path = file['name']
+                
+                if isinstance(file, dict):
+                    # Handle new Gradio File component format
+                    if 'name' in file:
+                        file_path = file['name']
+                    elif 'path' in file:
+                        file_path = file['path']
                 elif isinstance(file, str):
-                    # Older Gradio File component format
+                    # Handle string file paths
                     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
+                    for attr in ['name', 'path', 'file_path']:
+                        if hasattr(file, attr):
+                            file_path = getattr(file, attr)
+                            break
                 
-                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
+                if not file_path:
+                    print(f"⚠️ Could not determine file path for uploaded file {i+1}")
+                    continue
+                
+                if not os.path.exists(file_path):
+                    print(f"⚠️ File does not exist: {file_path}")
+                    continue
+                
+                # 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
+                try:
                     with open(file_path, 'rb') as f:
                         file_data = f.read()
                     
+                    if len(file_data) == 0:
+                        print(f"⚠️ Empty file: {file_path}")
+                        continue
+                    
                     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")
+                    print(f"✅ Processed {file_path} as {file_type} ({len(file_data)} bytes)")
+                    
+                except Exception as e:
+                    print(f"❌ Error reading file {file_path}: {str(e)}")
+                    continue
                     
             except Exception as e:
-                print(f"❌ Error processing uploaded file: {str(e)}")
+                print(f"❌ Error processing uploaded file {i+1}: {str(e)}")
                 continue
     
     if not processed_files:
         error_message = "No valid files were uploaded or processed."
-        progress_tracker.update(100, error_message)
+        progress_tracker.update(100, f"❌ {error_message}")
         progress_tracker.end_processing()
         return None, None, error_message
     
+    print(f"Successfully processed {len(processed_files)} files for analysis")
+    
     # Call the actual processing function
     try:
         combined_content, output_files, status = process_multiple_dashboards(
@@ -767,11 +851,28 @@ def process_dashboard(api_key, files, language_name, goal_description=None, num_
             model_name=model_name,
             custom_model=custom_model
         )
+        
+        # Validate output files exist and are accessible
+        if output_files:
+            valid_files = []
+            for file_path in output_files:
+                if os.path.exists(file_path) and os.path.getsize(file_path) > 0:
+                    valid_files.append(file_path)
+                else:
+                    print(f"⚠️ Output file not found or empty: {file_path}")
+            
+            if valid_files:
+                print(f"✅ Returning {len(valid_files)} valid output files")
+                return combined_content, valid_files, status
+            else:
+                return combined_content, None, "Analysis completed but no downloadable files were created."
+        
         return combined_content, output_files, status
+        
     except Exception as e:
         error_message = f"Error processing dashboards: {str(e)}"
-        print(error_message)
-        progress_tracker.update(100, error_message)
+        print(f"❌ {error_message}")
+        progress_tracker.update(100, f"❌ {error_message}")
         progress_tracker.end_processing()
         return None, None, error_message
 
@@ -792,7 +893,7 @@ def refresh_models(api_key):
         print(f"Error refreshing models: {str(e)}")
         return gr.Dropdown(choices=["custom"] + OPENROUTER_MODELS, value=DEFAULT_MODEL)
 
-# Define the Gradio interface
+# Define the Gradio interface with improved error handling
 with gr.Blocks(title="Dashboard Narrator - Powered by OpenRouter.ai", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
     # 📊 Dashboard Narrator - Powered by OpenRouter.ai
@@ -805,28 +906,37 @@ with gr.Blocks(title="Dashboard Narrator - Powered by OpenRouter.ai", theme=gr.t
     - Support for PNG and JPG image analysis
     - Enhanced with Claude Sonnet 4 and Gemini 2.5 Flash models
     - Multi-format dashboard analysis capabilities
+    - Improved file download functionality
     """)
     with gr.Row():
         with gr.Column(scale=1):
-            api_key = gr.Textbox(label="OpenRouter API Key", placeholder="Enter your OpenRouter API key...", type="password")
+            api_key = gr.Textbox(
+                label="OpenRouter API Key", 
+                placeholder="Enter your OpenRouter API key...", 
+                type="password",
+                info="Required - Get your API key from OpenRouter.ai"
+            )
             refresh_btn = gr.Button("🔄 Refresh Available Models", size="sm")
             
             model_choice = gr.Dropdown(
                 choices=["custom"] + OPENROUTER_MODELS,
                 value=DEFAULT_MODEL,
-                label="Select Model"
+                label="Select Model",
+                info="Choose an AI model for analysis"
             )
             
             custom_model = gr.Textbox(
                 label="Custom Model ID", 
                 placeholder="Enter custom model ID (e.g., anthropic/claude-3-opus:latest)...",
-                visible=False
+                visible=False,
+                info="Only shown when 'custom' is selected above"
             )
             
             language = gr.Dropdown(
                 choices=["Italiano", "English", "Français", "Español", "Deutsch"], 
                 value="English", 
-                label="Report Language"
+                label="Report Language",
+                info="Language for the generated reports"
             )
             
             num_sections = gr.Slider(
@@ -834,30 +944,40 @@ with gr.Blocks(title="Dashboard Narrator - Powered by OpenRouter.ai", theme=gr.t
                 maximum=10, 
                 value=4, 
                 step=1, 
-                label="Number of Vertical Sections per Dashboard"
+                label="Number of Vertical Sections per Dashboard",
+                info="How many sections to divide each dashboard into for analysis"
             )
             
             goal = gr.Textbox(
                 label="Analysis Goal (optional)", 
-                placeholder="E.g., Analyze Q1 2024 sales KPIs..."
+                placeholder="E.g., Analyze Q1 2024 sales KPIs...",
+                info="Specify what you want to focus on in the analysis"
             )
             
             files = gr.File(
                 label="Upload Dashboards (PDF, PNG, JPG)", 
                 file_types=[".pdf", ".png", ".jpg", ".jpeg"], 
-                file_count="multiple"
+                file_count="multiple",
+                info="Upload one or more dashboard files for analysis"
             )
             
-            analyze_btn = gr.Button("🔍 Analyze Dashboards", variant="primary")
+            analyze_btn = gr.Button("🔍 Analyze Dashboards", variant="primary", size="lg")
             
         with gr.Column(scale=2):
             with gr.Tab("Report"):
-                output_md = gr.Markdown(label="Analysis Report", value="")
-            with gr.Tab("Output Files"):
-                output_files = gr.File(label="Download Files")
-            output_status = gr.Textbox(label="Progress", placeholder="Upload dashboards and press Analyze...", interactive=False)
-            # Progress component doesn't accept label in Gradio 5.21.0
-            progress_bar = gr.Progress()
+                output_md = gr.Markdown(label="Analysis Report", value="Upload dashboards and click Analyze to get started...")
+            with gr.Tab("Download Files"):
+                output_files = gr.File(
+                    label="Download Generated Reports", 
+                    file_count="multiple",
+                    info="Generated markdown and PDF files will appear here after analysis"
+                )
+            output_status = gr.Textbox(
+                label="Status", 
+                placeholder="Upload dashboards and press Analyze to begin...", 
+                interactive=False,
+                info="Analysis progress and status updates"
+            )
     
     # Handle model dropdown change
     model_choice.change(
@@ -873,13 +993,14 @@ with gr.Blocks(title="Dashboard Narrator - Powered by OpenRouter.ai", theme=gr.t
         outputs=model_choice,
     )
     
-    # Handle analyze button
+    # Handle analyze button with improved error handling
     analyze_btn.click(
         fn=process_dashboard,
         inputs=[api_key, files, language, goal, num_sections, model_choice, custom_model],
-        outputs=[output_md, output_files, output_status]
+        outputs=[output_md, output_files, output_status],
+        show_progress=True
     )
 
 # Launch the app
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(share=True, show_error=True)