Update app.py

app.py

@@ -1,214 +1,173 @@
 import gradio as gr
 import pandas as pd
 from datetime import datetime
-import logging
-import io
+import json
 from transformers import pipeline
+import logging
+import os
+import plotly.express as px
 
-# Configure logging
+# Configure logging for debugging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
-# Load Hugging Face model
+# Load Hugging Face summarization model
 try:
-    logging.info("Loading Hugging Face model...")
-    summarizer = pipeline("text2text-generation", model="t5-small")  # Using t5-small for faster loading
-    logging.info("Model loaded successfully")
+    logging.info("Attempting to load Hugging Face model...")
+    summarizer = pipeline("text2text-generation", model="google/flan-t5-base")
+    logging.info("Hugging Face model loaded successfully")
 except Exception as e:
     logging.error(f"Failed to load model: {str(e)}")
     raise e
 
-# Summarize logs
+# Format summary prompt and generate report
 def summarize_logs(df, lab_name, start_date, end_date):
     try:
         total_devices = df["device_id"].nunique()
+        avg_uptime = "97%"  # Placeholder
         most_used = df.groupby("device_id")["usage_hours"].sum().idxmax() if not df.empty else "N/A"
+        downtime_events = 3  # Placeholder
+
         prompt = (
-            f"Summarize maintenance logs for lab {lab_name} "
+            f"Summarize maintenance and usage logs for lab {lab_name} "
             f"from {start_date} to {end_date}. "
-            f"Total devices: {total_devices}. Most used device: {most_used}."
+            f"There were {total_devices} devices. "
+            f"The most used device was {most_used}."
         )
-        logging.info("Generating summary with prompt: %s", prompt)
-        summary = summarizer(prompt, max_length=150, do_sample=False)[0]["generated_text"]
-        logging.info("Summary generated: %s", summary)
+        summary = summarizer(prompt, max_length=200, do_sample=False)[0]["generated_text"]
+        logging.info("Summary generated successfully")
         return summary
     except Exception as e:
         logging.error(f"Summary generation failed: {str(e)}")
-        return f"Error generating summary: {str(e)}"
+        return "Failed to generate summary."
 
-# Generate text response
-def generate_text_response(df, lab_name, start_date, end_date):
+# Create a bar chart for usage hours per device
+def create_usage_chart(df):
     try:
-        total_usage = df["usage_hours"].sum()
-        avg_usage_per_device = df.groupby("device_id")["usage_hours"].sum().mean()
-        response = (
-            f"Maintenance Report for {lab_name} ({start_date} to {end_date}):\n"
-            f"- Total Usage Hours: {total_usage:.2f} hours\n"
-            f"- Average Usage per Device: {avg_usage_per_device:.2f} hours\n"
-            f"- Number of Devices: {df['device_id'].nunique()}\n"
-            f"- Period Covered: {start_date} to {end_date}"
+        usage_data = df.groupby("device_id")["usage_hours"].sum().reset_index()
+        fig = px.bar(
+            usage_data,
+            x="device_id",
+            y="usage_hours",
+            title="Usage Hours per Device",
+            labels={"device_id": "Device ID", "usage_hours": "Usage Hours"},
+            color="usage_hours",
+            color_continuous_scale="Blues"
         )
-        logging.info("Text response generated: %s", response)
-        return response
+        fig.update_layout(
+            title_font_size=16,
+            margin=dict(l=20, r=20, t=40, b=20),
+            plot_bgcolor="white",
+            paper_bgcolor="white",
+            font=dict(size=12)
+        )
+        return fig
     except Exception as e:
-        logging.error(f"Text response generation failed: {str(e)}")
-        return f"Error generating text response: {str(e)}"
+        logging.error(f"Failed to create usage chart: {str(e)}")
+        return None
 
-# Generate suggested actions
-def generate_suggested_actions(df):
+# Main Gradio function
+def process_logs(file_obj, lab_site, start_date, end_date):
     try:
-        high_usage_devices = df.groupby("device_id")["usage_hours"].sum()
-        high_usage_devices = high_usage_devices[high_usage_devices > 5].index.tolist()  # Lowered threshold
-        if high_usage_devices:
-            actions = (
-                f"Suggested Actions:\n"
-                f"- Inspect Devices: {', '.join(map(str, high_usage_devices))} have high usage (>5 hours). Schedule maintenance.\n"
-                f"- Load Balancing: Redistribute workload.\n"
-                f"- Monitor Downtime: Minimize downtime events."
-            )
+        if file_obj is None:
+            logging.warning("No file uploaded, returning empty results")
+            return "No file uploaded.", "No data to preview.", None
+        
+        # Read file based on extension
+        file_name = file_obj.name if hasattr(file_obj, 'name') else file_obj
+        logging.info(f"Processing file: {file_name}")
+        
+        if file_name.endswith(".json"):
+            df = pd.read_json(file_name)
+        elif file_name.endswith(".csv"):
+            df = pd.read_csv(file_name)
         else:
-            actions = (
-                "Suggested Actions:\n"
-                "- Routine Maintenance: No devices exceed usage thresholds.\n"
-                "- Monitor Trends: Track usage patterns."
-            )
-        logging.info("Suggested actions generated: %s", actions)
-        return actions
-    except Exception as e:
-        logging.error(f"Suggested actions generation failed: {str(e)}")
-        return f"Error generating suggested actions: {str(e)}"
+            logging.error("Unsupported file format")
+            return "Unsupported file format. Please upload a CSV or JSON file.", None, None
 
-# Generate downloadable report
-def generate_maintenance_report(df, lab_name, start_date, end_date):
-    try:
-        report_data = {
-            "Lab Name": [lab_name] * len(df),
-            "Device ID": df["device_id"],
-            "Usage Hours": df["usage_hours"],
-            "Timestamp": df["timestamp"],
-            "Report Period Start": [start_date] * len(df),
-            "Report Period End": [end_date] * len(df)
-        }
-        report_df = pd.DataFrame(report_data)
-        output = io.StringIO()
-        report_df.to_csv(output, index=False)
-        output.seek(0)
-        logging.info("Maintenance report generated")
-        return output.getvalue(), f"{lab_name}_maintenance_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
-    except Exception as e:
-        logging.error(f"Report generation failed: {str(e)}")
-        return None, None
+        logging.info(f"File loaded successfully with {len(df)} rows")
 
-# Main processing function
-def process_logs(file_obj, lab_site, start_date, end_date):
-    try:
-        # Fallback data if no file is uploaded
-        if not file_obj:
-            logging.warning("No file uploaded, using sample data")
-            df = pd.DataFrame({
-                "device_id": ["Device1", "Device2", "Device1"],
-                "usage_hours": [5.5, 3.2, 4.0],
-                "timestamp": ["2025-05-01 10:00:00", "2025-05-02 12:00:00", "2025-05-03 14:00:00"]
-            })
-            df["timestamp"] = pd.to_datetime(df["timestamp"])
-        else:
-            logging.info(f"Processing file: {file_obj.name}")
-            if file_obj.name.endswith(".json"):
-                df = pd.read_json(file_obj)
-            elif file_obj.name.endswith(".csv"):
-                df = pd.read_csv(file_obj)
-            else:
-                logging.error("Unsupported file format")
-                return "Upload a CSV or JSON file.", None, None, None, None
-
-        logging.info(f"Loaded data with {len(df)} rows")
-
-        # Filter by date range
+        # Convert timestamp to datetime and filter by date range
         try:
             df["timestamp"] = pd.to_datetime(df["timestamp"])
             start_date = pd.to_datetime(start_date)
             end_date = pd.to_datetime(end_date)
             df = df[(df["timestamp"] >= start_date) & (df["timestamp"] <= end_date)]
-            logging.info(f"Filtered to {len(df)} rows")
-            if df.empty:
-                return "No data in date range.", None, None, None, None
+            logging.info(f"Filtered to {len(df)} rows within date range {start_date} to {end_date}")
         except Exception as e:
             logging.error(f"Date filtering failed: {str(e)}")
-            return f"Date filtering error: {str(e)}", None, None, None, None
+            return f"Failed to filter data by date: {str(e)}", None, None
+
+        if df.empty:
+            logging.warning("No data within the specified date range")
+            return "No data available for the specified date range.", "No data to preview.", None
 
-        text_response = generate_text_response(df, lab_site, start_date, end_date)
-        maintenance_report, report_filename = generate_maintenance_report(df, lab_site, start_date, end_date)
-        suggested_actions = generate_suggested_actions(df)
         summary = summarize_logs(df, lab_site, start_date, end_date)
+        preview = df.head().to_markdown() if not df.empty else "No data available."
+        chart = create_usage_chart(df)
 
-        return text_response, maintenance_report, suggested_actions, summary, report_filename
+        return summary, preview, chart
     except Exception as e:
-        logging.error(f"Processing failed: {str(e)}")
-        return f"Error processing file: {str(e)}", None, None, None, None
-
-# Gradio Interface
-def create_gradio_interface():
-    css = """
-        .report-container {border: 1px solid #e0e0e0; padding: 15px; border-radius: 8px; background-color: #f5f5f5;}
-        .report-title {font-size: 28px; font-weight: bold; margin-bottom: 15px; color: #333;}
-        .report-section {margin-bottom: 20px;}
-        .report-section h3 {font-size: 20px; margin-bottom: 8px; color: #555;}
-    """
-    
-    with gr.Blocks(css=css, theme=gr.themes.Soft()) as iface:
-        gr.Markdown("<h1>LabOps Maintenance Report Generator</h1>")
-        gr.Markdown("Upload a CSV or JSON file to generate a maintenance report. Use format: device_id, usage_hours, timestamp.")
+        logging.error(f"Failed to process file: {str(e)}")
+        return f"Failed to process file: {str(e)}", None, None
+
+# Gradio Interface with Dashboard Layout
+try:
+    logging.info("Initializing Gradio Blocks interface...")
+    with gr.Blocks(css="""
+        .dashboard-container {border: 1px solid #e0e0e0; padding: 10px; border-radius: 5px; background-color: #f9f9f9;}
+        .dashboard-title {font-size: 24px; font-weight: bold; margin-bottom: 10px;}
+        .dashboard-section {margin-bottom: 15px;}
+        .dashboard-section h3 {font-size: 18px; margin-bottom: 5px;}
+    """) as iface:
+        gr.Markdown("<h1>LabOps Log Analyzer Dashboard (Hugging Face AI)</h1>")
+        gr.Markdown("Upload a CSV or JSON file containing lab equipment logs to analyze usage.")
 
         with gr.Row():
             with gr.Column(scale=1):
                 file_input = gr.File(label="Upload Logs (CSV or JSON)", file_types=[".csv", ".json"])
                 lab_site_input = gr.Textbox(label="Lab Site", placeholder="e.g., Lab A")
-                start_date_input = gr.Textbox(label="Start Date (YYYY-MM-DD)", placeholder="e.g., 2025-05-01")
-                end_date_input = gr.Textbox(label="End Date (YYYY-MM-DD)", placeholder="e.g., 2025-05-30")
-                submit_button = gr.Button("Generate Report", variant="primary")
+                start_date_input = gr.Textbox(label="Start Date (YYYY-MM-DD)", placeholder="e.g., 2025-01-01")
+                end_date_input = gr.Textbox(label="End Date (YYYY-MM-DD)", placeholder="e.g., 2025-01-31")
+                submit_button = gr.Button("Submit", variant="primary")
             
             with gr.Column(scale=2):
-                with gr.Group(elem_classes="report-container"):
-                    gr.Markdown("<div class='report-title'>Maintenance Report</div>")
-                    
-                    with gr.Row():
-                        with gr.Column():
-                            with gr.Group(elem_classes="report-section"):
-                                gr.Markdown("### Report Overview")
-                                text_response_output = gr.Textbox(lines=6, show_copy_button=True, label="")
+                with gr.Group(elem_classes="dashboard-container"):
+                    gr.Markdown("<div class='dashboard-title'>Analysis Dashboard</div>")
                     
                     with gr.Row():
-                        with gr.Column():
-                            with gr.Group(elem_classes="report-section"):
-                                gr.Markdown("### Download Report")
-                                maintenance_report_output = gr.File(label="Download CSV")
+                        with gr.Column(scale=1):
+                            with gr.Group(elem_classes="dashboard-section"):
+                                gr.Markdown("### Summary Report")
+                                summary_output = gr.Textbox(lines=5)
                     
                     with gr.Row():
-                        with gr.Column():
-                            with gr.Group(elem_classes="report-section"):
-                                gr.Markdown("### Suggested Actions")
-                                suggested_actions_output = gr.Textbox(lines=6, show_copy_button=True, label="")
-                    
-                    with gr.Row():
-                        with gr.Column():
-                            with gr.Group(elem_classes="report-section"):
-                                gr.Markdown("### Summary")
-                                summary_output = gr.Textbox(lines=6, show_copy_button=True, label="")
+                        with gr.Column(scale=1):
+                            with gr.Group(elem_classes="dashboard-section"):
+                                gr.Markdown("### Usage Chart")
+                                chart_output = gr.Plot()
+                        
+                        with gr.Column(scale=1):
+                            with gr.Group(elem_classes="dashboard-section"):
+                                gr.Markdown("### Log Preview")
+                                preview_output = gr.Markdown()
 
         submit_button.click(
             fn=process_logs,
             inputs=[file_input, lab_site_input, start_date_input, end_date_input],
-            outputs=[text_response_output, maintenance_report_output, suggested_actions_output, summary_output, maintenance_report_output]
+            outputs=[summary_output, preview_output, chart_output]
         )
-    
-    return iface
+
+    logging.info("Gradio interface initialized successfully")
+except Exception as e:
+    logging.error(f"Failed to initialize Gradio interface: {str(e)}")
+    raise e
 
 if __name__ == "__main__":
     try:
-        logging.info("Starting Gradio interface...")
-        iface = create_gradio_interface()
-        iface.launch(server_name="0.0.0.0", server_port=7860, debug=True)
-        logging.info("Interface launched successfully")
+        logging.info("Launching Gradio interface...")
+        iface.launch(server_name="0.0.0.0", server_port=7860, debug=True, share=False)
+        logging.info("Gradio interface launched successfully")
     except Exception as e:
-        logging.error(f"Failed to launch interface: {str(e)}")
+        logging.error(f"Failed to launch Gradio interface: {str(e)}")
         print(f"Error launching app: {str(e)}")
         raise e