Update app.py

app.py

@@ -1,105 +1,191 @@
-import gradio as gr
 import pandas as pd
-import numpy as np
-import matplotlib.pyplot as plt
-import seaborn as sns
-from sklearn.linear_model import LogisticRegression
-from sklearn.preprocessing import StandardScaler
-import io
-import base64
+import requests
+import gradio as gr
+import logging
+from uuid import uuid4
 
-# Load equipment data
-def load_data():
-    df = pd.read_csv("equipment_data.csv")
-    return df
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
 
-# Mock AI model for suggestions
-def predict_suggestions(df):
-    X = df[["Usage_Hours__c", "Idle_Hours__c", "Utilization_Score__c"]].fillna(0)
-    scaler = StandardScaler()
-    X_scaled = scaler.fit_transform(X)
-    
-    suggestions = ["Move", "Pause Rent", "Repair", "Replace"]
-    y = np.random.choice(suggestions, size=len(df))  # Mock model
-    
-    model = LogisticRegression()
-    model.fit(X_scaled, y)
-    
-    probs = model.predict_proba(X_scaled)
-    df["AI_Suggestion__c"] = model.predict(X_scaled)
-    df["Suggestion_Confidence__c"] = probs.max(axis=1) * 100
-    return df
+# FastAPI endpoint
+FASTAPI_ENDPOINT = "http://localhost:8000/predict"
 
-# Generate equipment cards
-def generate_cards(df, project_filter, suggestion_filter):
-    filtered_df = df
-    if project_filter and project_filter != "All":
-        filtered_df = filtered_df[filtered_df["Project_ID__c"] == project_filter]
-    if suggestion_filter and suggestion_filter != "All":
-        filtered_df = filtered_df[filtered_df["AI_Suggestion__c"] == suggestion_filter]
-    
-    cards = ""
-    for _, row in filtered_df.iterrows():
-        card = f"""
-        **Equipment ID**: {row['Equipment_ID__c']}  
-        **Project**: {row['Project_ID__c']}  
-        **Usage Hours**: {row['Usage_Hours__c']}  
-        **Idle Hours**: {row['Idle_Hours__c']}  
-        **Utilization Score**: {row['Utilization_Score__c']}%  
-        **AI Suggestion**: {row['AI_Suggestion__c']} (Confidence: {row['Suggestion_Confidence__c']:.2f}%)  
-        **Last Maintenance**: {row['Last_Maintenance__c']}  
-        """
-        cards += card + "\n---\n"
-    return cards if cards else "No equipment matches the filters."
+# Load and validate dataset
+def load_dataset(file_path="equipment_data.csv"):
+    try:
+        df = pd.read_csv(file_path)
+        required_columns = ["Equipment_ID__c", "Equipment_Type__c", "Usage_Hours__c", "Idle_Hours__c"]
+        optional_columns = ["Movement_Frequency__c", "Cost_Per_Hour__c"]
+        missing_required = [col for col in required_columns if col not in df.columns]
+        if missing_required:
+            logger.error(f"Missing required columns: {missing_required}")
+            return None
+        
+        # Ensure numeric columns are properly typed
+        numeric_cols = [col for col in required_columns + optional_columns if col in df.columns and col != "Equipment_ID__c" and col != "Equipment_Type__c"]
+        for col in numeric_cols:
+            df[col] = pd.to_numeric(df[col], errors='coerce')
+        
+        # Fill NaN values in numeric columns with 0
+        if df[numeric_cols].isnull().any().any():
+            logger.warning("NaN values detected in numeric columns, filling with 0")
+            df[numeric_cols] = df[numeric_cols].fillna(0)
+        
+        # Add missing optional columns with default value 0
+        for col in optional_columns:
+            if col not in df.columns:
+                logger.warning(f"Optional column {col} missing, adding with default value 0")
+                df[col] = 0.0
+                
+        return df
+    except FileNotFoundError:
+        logger.error(f"Dataset file {file_path} not found")
+        return None
+    except Exception as e:
+        logger.error(f"Failed to load dataset: {e}")
+        return None
 
-# Generate heatmap
-def generate_heatmap(df):
-    dates = pd.date_range(start="2025-05-01", end="2025-05-07", freq="D")
-    equipment = df["Equipment_ID__c"].unique()
-    heatmap_data = np.random.rand(len(equipment), len(dates)) * 100  # Mock data
-    plt.figure(figsize=(10, 6))
-    sns.heatmap(heatmap_data, xticklabels=dates.strftime("%Y-%m-%d"), yticklabels=equipment, cmap="YlGnBu")
-    plt.title("Weekly Utilization Heatmap")
-    
-    buffer = io.BytesIO()
-    plt.savefig(buffer, format="png")
-    buffer.seek(0)
-    img_str = base64.b64encode(buffer.getvalue()).decode()
-    plt.close()
-    return f"![Heatmap](data:image/png;base64,{img_str})"
+# Load dataset
+df = load_dataset()
+equipment_types = sorted(df["Equipment_Type__c"].dropna().unique().tolist()) if df is not None and not df.empty else ["No Equipment Types"]
+suggestion_types = ["Move", "Pause Rent", "Repair", "Replace"]
+
+# Call FastAPI endpoint
+def call_model(row):
+    try:
+        # Prepare inputs
+        inputs = {
+            "usage_hours": float(row["Usage_Hours__c"]),
+            "idle_hours": float(row["Idle_Hours__c"]),
+            "movement_frequency": float(row.get("Movement_Frequency__c", 0.0)),
+            "cost_per_hour": float(row.get("Cost_Per_Hour__c", 0.0))
+        }
+        
+        logger.info(f"Sending request with inputs: {inputs}")  # Log inputs
+        
+        response = requests.post(FASTAPI_ENDPOINT, json=inputs, timeout=10)
+        response.raise_for_status()
+        result = response.json()
+        
+        # Log the API response
+        logger.info(f"Received response: {result}")
+        
+        suggestion = result.get("suggestion", "Replace")
+        confidence = float(result.get("confidence", 0.5))
+        
+        if suggestion not in suggestion_types:
+            logger.warning(f"Invalid suggestion: {suggestion}, defaulting to Replace")
+            suggestion = "Replace"
+        
+        if not (0 <= confidence <= 1):
+            logger.warning(f"Invalid confidence: {confidence}, defaulting to 0.5")
+            confidence = 0.5
+        
+        return suggestion, confidence
+    except (requests.RequestException, ValueError, KeyError) as e:
+        logger.error(f"API call failed: {e}")
+        return "Replace", 0.5
 
-# Export data as CSV
-def export_csv(df):
-    return df.to_csv(index=False)
+# Filter equipment and generate display
+def filter_equipment(equipment_type, suggestion):
+    if not equipment_type or not suggestion or df is None or df.empty:
+        return "No data available or invalid filters selected.", ""
+    
+    try:
+        filtered = df[df["Equipment_Type__c"].str.lower() == equipment_type.lower()].copy()
+        if filtered.empty:
+            return f"No equipment found for type: {equipment_type}.", ""
+        
+        # Apply model predictions
+        filtered["AI_Suggestion__c"] = None
+        filtered["Suggestion_Confidence__c"] = 0.0
+        for idx, row in filtered.iterrows():
+            s, conf = call_model(row)
+            filtered.at[idx, "AI_Suggestion__c"] = s
+            filtered.at[idx, "Suggestion_Confidence__c"] = conf
+        
+        # Filter by suggestion
+        filtered = filtered[filtered["AI_Suggestion__c"].str.lower() == suggestion.lower()]
+        if filtered.empty:
+            return f"No equipment with suggestion '{suggestion}' for type '{equipment_type}'.", ""
+        
+        # Generate display cards
+        cards = [
+            f"ID: {row['Equipment_ID__c']} | Usage: {row['Usage_Hours__c']:.2f} hrs | "
+            f"Idle: {row['Idle_Hours__c']:.2f} hrs | Move Freq: {row['Movement_Frequency__c']:.2f} | "
+            f"Cost/hr: ${row['Cost_Per_Hour__c']:.2f} | AI: {row['AI_Suggestion__c']} "
+            f"({row['Suggestion_Confidence__c']:.2%})"
+            for _, row in filtered.iterrows()
+        ]
+        confidences = [f"{row['Equipment_ID__c']}: {row['Suggestion_Confidence__c']:.2%}" 
+                      for _, row in filtered.iterrows()]
+        return "\n\n".join(cards), "\n".join(confidences)
+    except Exception as e:
+        logger.error(f"Error in filter_equipment: {e}")
+        return "An error occurred while filtering equipment.", ""
 
-# Main Gradio interface
-def main(project_filter="All", suggestion_filter="All"):
-    df = load_data()
-    df = predict_suggestions(df)
-    cards = generate_cards(df, project_filter, suggestion_filter)
-    heatmap = generate_heatmap(df)
-    csv_data = export_csv(df)
-    return cards, heatmap, csv_data
+# Export filtered data to CSV
+def export_csv(equipment_type, suggestion):
+    if not equipment_type or not suggestion or df is None or df.empty:
+        return None
+    
+    try:
+        filtered = df[df["Equipment_Type__c"].str.lower() == equipment_type.lower()].copy()
+        if filtered.empty:
+            return None
+        
+        # Apply model predictions
+        filtered["AI_Suggestion__c"] = None
+        filtered["Suggestion_Confidence__c"] = 0.0
+        for idx, row in filtered.iterrows():
+            s, conf = call_model(row)
+            filtered.at[idx, "AI_Suggestion__c"] = s
+            filtered.at[idx, "Suggestion_Confidence__c"] = conf
+        
+        # Filter by suggestion
+        filtered = filtered[filtered["AI_Suggestion__c"].str.lower() == suggestion.lower()]
+        if filtered.empty:
+            return None
+        
+        # Export to CSV
+        filename = f"filtered_equipment_{uuid4().hex[:8]}.csv"
+        filtered.to_csv(filename, index=False)
+        return filename
+    except Exception as e:
+        logger.error(f"Error in export_csv: {e}")
+        return None
 
-# Gradio interface
-with gr.Blocks() as demo:
+# Build Gradio UI
+with gr.Blocks(theme=gr.themes.Soft()) as app:
     gr.Markdown("# Equipment Utilization Dashboard")
+    gr.Markdown("Filter equipment by type and AI suggestion to optimize utilization.")
     
     with gr.Row():
-        project_filter = gr.Dropdown(choices=["All", "PRJ001", "PRJ002"], label="Filter by Project")
-        suggestion_filter = gr.Dropdown(choices=["All", "Move", "Pause Rent", "Repair", "Replace"], label="Filter by Suggestion")
+        etype = gr.Dropdown(choices=equipment_types, label="Equipment Type", 
+                           value=equipment_types[0] if equipment_types else None)
+        suggestion = gr.Dropdown(choices=suggestion_types, label="Suggestion Type", value=suggestion_types[0])
     
-    with gr.Row():
-        cards_output = gr.Markdown(label="Equipment Cards")
+    results = gr.Textbox(label="Equipment Details", lines=10, placeholder="Select equipment type and suggestion...")
+    confidences = gr.Textbox(label="Confidence Scores", lines=5, placeholder="Confidence scores will appear here...")
     
     with gr.Row():
-        heatmap_output = gr.Markdown(label="Utilization Heatmap")
+        export_button = gr.Button("Export to CSV", variant="primary")
     
-    with gr.Row():
-        export_button = gr.File(label="Download CSV", value=lambda: export_csv(load_data()))
+    file_output = gr.File(label="Download CSV")
     
-    project_filter.change(main, inputs=[project_filter, suggestion_filter], outputs=[cards_output, heatmap_output, export_button])
-    suggestion_filter.change(main, inputs=[project_filter, suggestion_filter], outputs=[cards_output, heatmap_output, export_button])
+    # Define interactions
+    etype.change(fn=filter_equipment, inputs=[etype, suggestion], outputs=[results, confidences])
+    suggestion.change(fn=filter_equipment, inputs=[etype, suggestion], outputs=[results, confidences])
+    export_button.click(
+        fn=export_csv, 
+        inputs=[etype, suggestion], 
+        outputs=file_output
+    )
 
+# Launch the app
 if __name__ == "__main__":
-    demo.launch()
+    try:
+        app.launch(debug=False, share=False)
+    except Exception as e:
+        logger.error(f"Failed to launch Gradio app: {e}")