Upload 6 files

Dockerfile

@@ -0,0 +1,16 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY app.py .
+COPY model.py .
+COPY utils.py .
+COPY models/delay_model.pth models/delay_model.pth
+COPY models/scaler.pkl models/scaler.pkl
+
+EXPOSE 8501
+
+CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

README.md

@@ -0,0 +1,42 @@
+---
+title: Delay Predictor
+emoji: 🚀
+colorFrom: red
+colorTo: red
+sdk: docker
+app_port: 8501
+tags:
+- streamlit
+- distilbart
+- project-delay
+pinned: false
+short_description: Streamlit app for project delay prediction using DistilBART
+---
+
+# Project Delay Predictor
+
+This Streamlit app predicts project delays based on task data, workforce, and weather conditions, using DistilBART (`sshleifer/distilbart-cnn-6-6`) for AI-generated insights. It runs on the free CPU tier of Hugging Face Spaces, generating delay probabilities, insights, and a downloadable PDF report, with integration to Salesforce.
+
+## Features
+- Input project details via a Streamlit interface.
+- Predict delay probability and generate AI insights.
+- Visualize delay risk with an interactive Chart.js heatmap.
+- Save results and PDF to Salesforce.
+- Download a PDF report.
+
+## Setup
+1. Ensure Salesforce credentials are set as environment variables (`SF_USERNAME`, `SF_PASSWORD`, `SF_SECURITY_TOKEN`, `SF_INSTANCE_URL`).
+2. Deploy on a Hugging Face Space with the free CPU tier.
+3. Access the app at the Space's URL.
+
+## Notes
+- Uses DistilBART for CPU-friendly inference (~5-10 seconds per prediction).
+- Secure model loading with `safetensors` and `trust_remote_code=False`.
+- Includes logging for debugging and rule-based fallback insights if the model fails.
+
+## Troubleshooting
+- **AI Insights Unavailable**: Check Space logs for errors (e.g., memory issues, network failures). Restart the Space or reduce `max_new_tokens` in `model.py`.
+- **Slow Inference**: CPU inference may take ~5-10 seconds. Consider switching to `t5-small` for faster performance.
+- **Dependency Errors**: Ensure all dependencies in `requirements.txt` are installed correctly.
+
+For questions, refer to [Streamlit documentation](https://docs.streamlit.io) or [Hugging Face forums](https://discuss.huggingface.co).

app.py

@@ -0,0 +1,493 @@
+import streamlit as st
+import streamlit.components.v1 as components
+import pandas as pd
+import matplotlib.pyplot as plt
+import plotly.figure_factory as ff
+import os
+from datetime import datetime, timedelta
+import json
+import requests
+import base64
+import logging
+from model import predict_delay, get_weather_condition
+from utils import validate_inputs, generate_heatmap
+from reportlab.lib.pagesizes import letter
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Image
+from reportlab.lib.styles import getSampleStyleSheet
+from reportlab.lib.units import inch
+from io import BytesIO
+from simple_salesforce import Salesforce
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Streamlit app configuration
+st.set_page_config(page_title="Delay 🚀", layout="wide")
+
+# Salesforce connection (using environment variables)
+try:
+    sf_instance_url = os.environ.get("SF_INSTANCE_URL")
+    if not sf_instance_url:
+        raise ValueError("SF_INSTANCE_URL environment variable not set")
+    if "lightning.force.com" in sf_instance_url:
+        logger.warning("SF_INSTANCE_URL contains lightning.force.com; consider using my.salesforce.com for reliable PDF downloads")
+    sf = Salesforce(
+        username=os.environ.get("SF_USERNAME"),
+        password=os.environ.get("SF_PASSWORD"),
+        security_token=os.environ.get("SF_SECURITY_TOKEN"),
+        instance_url=sf_instance_url
+    )
+except Exception as e:
+    st.error(f"Failed to connect to Salesforce: {str(e)}")
+    logger.error(f"Salesforce connection failed: {str(e)}")
+    sf = None
+
+# Weather API configuration
+WEATHER_API_KEY = os.environ.get("WEATHER_API_KEY")
+WEATHER_API_URL = "http://api.openweathermap.org/data/2.5/forecast"
+
+# Title
+st.title("Project Delay Predictor 🚀")
+
+# Task options per phase
+task_options = {
+    "Planning": ["Define Scope", "Resource Allocation", "Permit Acquisition"],
+    "Design": ["Architectural Drafting", "Engineering Analysis", "Design Review"],
+    "Construction": ["Foundation Work", "Structural Build", "Utility Installation"]
+}
+
+# Initialize session state
+if 'phase' not in st.session_state:
+    st.session_state.phase = ""
+if 'task' not in st.session_state:
+    st.session_state.task = ""
+if 'weather_data' not in st.session_state:
+    st.session_state.weather_data = None
+
+# Function to fetch weather data
+def fetch_weather_data(project_location, date):
+    if not WEATHER_API_KEY:
+        logger.error("WEATHER_API_KEY not set")
+        return None, {"error": "Weather API key not set. Please provide a valid API key."}
+    try:
+        params = {
+            "q": project_location,
+            "appid": WEATHER_API_KEY,
+            "units": "metric"
+        }
+        response = requests.get(WEATHER_API_URL, params=params)
+        response.raise_for_status()
+        data = response.json()
+        
+        # Find the closest forecast to the target date
+        target_date = datetime.strptime(date, "%Y-%m-%d")
+        closest_forecast = None
+        min_time_diff = float('inf')
+        
+        for forecast in data['list']:
+            forecast_time = datetime.fromtimestamp(forecast['dt'])
+            time_diff = abs((forecast_time - target_date).total_seconds())
+            if time_diff < min_time_diff:
+                min_time_diff = time_diff
+                closest_forecast = forecast
+        
+        if not closest_forecast:
+            return None, {"error": "No forecast available for the specified date."}
+        
+        # Map weather conditions to impact score
+        weather_main = forecast['weather'][0]['main'].lower()
+        impact_score = 50  # Default
+        if 'clear' in weather_main:
+            impact_score = 10
+        elif 'clouds' in weather_main:
+            impact_score = 30 if forecast['clouds']['all'] < 50 else 50
+        elif 'rain' in weather_main:
+            impact_score = 70 if forecast['rain'].get('3h', 0) < 2.5 else 85
+        elif 'storm' in weather_main or 'thunderstorm' in weather_main:
+            impact_score = 90
+        
+        weather_condition = get_weather_condition(impact_score)
+        return {
+            "weather_impact_score": impact_score,
+            "weather_condition": weather_condition,
+            "temperature": forecast['main']['temp'],
+            "humidity": forecast['main']['humidity']
+        }, None
+    except Exception as e:
+        logger.error(f"Failed to fetch weather data: {str(e)}")
+        return None, {"error": f"Failed to fetch weather data for {project_location}: {str(e)}"}
+
+# Function to format high_risk_phases with flag and alert
+def format_high_risk_phases(high_risk_phases):
+    formatted = []
+    for phase in high_risk_phases:
+        flag = "🚩" if phase['risk'] > 75 else ""
+        alert = "[Alert]" if phase['risk'] > 75 else ""
+        formatted.append(f"{flag} {phase['phase']}: {phase['task']} (Risk: {phase['risk']:.1f}%) {alert}")
+    return formatted
+
+# Function to generate Gantt chart
+def generate_gantt_chart(input_data, prediction):
+    try:
+        phase = input_data["phase"]
+        task = input_data["task"]
+        expected_duration = input_data["task_expected_duration"]
+        actual_duration = input_data["task_actual_duration"]
+        forecast_date = datetime.strptime(input_data["weather_forecast_date"], "%Y-%m-%d")
+        delay_risk = prediction["delay_probability"]
+
+        # Calculate start and end dates
+        start_date = forecast_date - timedelta(days=max(expected_duration, actual_duration))
+        expected_end = start_date + timedelta(days=expected_duration)
+        actual_end = start_date + timedelta(days=actual_duration) if actual_duration > 0 else expected_end
+
+        # Prepare Gantt chart data
+        df = [
+            dict(Task=f"{phase}: {task} (Expected)", Start=start_date.strftime("%Y-%m-%d"), Finish=expected_end.strftime("%Y-%m-%d"), Resource="Expected", Risk=delay_risk),
+            dict(Task=f"{phase}: {task} (Actual)", Start=start_date.strftime("%Y-%m-%d"), Finish=actual_end.strftime("%Y-%m-%d"), Resource="Actual", Risk=delay_risk)
+        ]
+
+        # Color based on delay risk
+        colors = {
+            "Expected": "rgb(0, 255, 0)" if delay_risk <= 50 else "rgb(255, 255, 0)" if delay_risk <= 75 else "rgb(255, 0, 0)",
+            "Actual": "rgb(0, 200, 0)" if delay_risk <= 50 else "rgb(200, 200, 0)" if delay_risk <= 75 else "rgb(200, 0, 0)"
+        }
+
+        # Create Gantt chart
+        fig = ff.create_gantt(
+            df,
+            colors=colors,
+            index_col="Resource",
+            title=f"Gantt Chart for {phase}: {task}",
+            show_colorbar=True,
+            bar_width=0.4,
+            showgrid_x=True,
+            showgrid_y=True
+        )
+        fig.update_layout(
+            xaxis_title="Timeline",
+            yaxis_title="Task",
+            height=300,
+            margin=dict(l=150)
+        )
+        return fig
+    except Exception as e:
+        logger.error(f"Failed to generate Gantt chart: {str(e)}")
+        return None
+
+# Function to generate PDF
+def generate_pdf(input_data, prediction, heatmap_fig, gantt_fig):
+    buffer = BytesIO()
+    doc = SimpleDocTemplate(buffer, pagesize=letter)
+    styles = getSampleStyleSheet()
+    story = []
+
+    # Title
+    story.append(Paragraph("Project Delay Prediction Report", styles['Title']))
+    story.append(Spacer(1, 12))
+
+    # Input Data
+    story.append(Paragraph("Input Data", styles['Heading2']))
+    input_fields = [
+        f"Project Name: {input_data['project_name']}",
+        f"Phase: {input_data['phase']}",
+        f"Task: {input_data['task']}",
+        f"Current Progress: {input_data['current_progress']}%",
+        f"Task Expected Duration: {input_data['task_expected_duration']} days",
+        f"Task Actual Duration: {input_data['task_actual_duration']} days",
+        f"Workforce Gap: {input_data['workforce_gap']}%",
+        f"Workforce Skill Level: {input_data['workforce_skill_level']}",
+        f"Workforce Shift Hours: {input_data['workforce_shift_hours']}",
+        f"Weather Impact Score: {input_data['weather_impact_score']}",
+        f"Weather Condition: {input_data['weather_condition']}",
+        f"Weather Forecast Date: {input_data['weather_forecast_date']}",
+        f"Project Location: {input_data['project_location']}"
+    ]
+    for field in input_fields:
+        story.append(Paragraph(field, styles['Normal']))
+    story.append(Spacer(1, 12))
+
+    # Prediction Results
+    story.append(Paragraph("Prediction Results", styles['Heading2']))
+    high_risk_text = "<br/>".join(format_high_risk_phases(prediction['high_risk_phases']))
+    
+    # Check for 2-week risk alert in AI insights
+    two_week_alert = next((insight for insight in prediction['ai_insights'].split("; ") if "2-Week Risk Alert" in insight), None)
+    if two_week_alert:
+        story.append(Paragraph("2-Week Risk Alert", styles['Heading3']))
+        story.append(Paragraph(two_week_alert, styles['Normal']))
+        story.append(Spacer(1, 12))
+    
+    prediction_fields = [
+        f"Delay Probability: {prediction['delay_probability']:.2f}%",
+        f"High Risk Phases:<br/>{high_risk_text}",
+        f"AI Insights: {prediction['ai_insights']}",
+        f"Weather Condition: {prediction['weather_condition']}"
+    ]
+    for field in prediction_fields:
+        story.append(Paragraph(field, styles['Normal']))
+    story.append(Spacer(1, 12))
+
+    # Heatmap
+    story.append(Paragraph("Delay Risk Heatmap", styles['Heading2']))
+    img_buffer = BytesIO()
+    heatmap_fig.savefig(img_buffer, format='png', bbox_inches='tight')
+    img_buffer.seek(0)
+    story.append(Image(img_buffer, width=6*inch, height=2*inch))
+    story.append(Spacer(1, 12))
+
+    # Gantt Chart
+    if gantt_fig:
+        story.append(Paragraph("Gantt Chart", styles['Heading2']))
+        gantt_buffer = BytesIO()
+        try:
+            gantt_fig.write_image(gantt_buffer, format='PNG')
+            gantt_buffer.seek(0)
+            story.append(Image(gantt_buffer, width=6*inch, height=3*inch))
+        except Exception as e:
+            logger.error(f"Failed to include Gantt chart in PDF: {str(e)}")
+            story.append(Paragraph("Gantt Chart unavailable due to rendering issues.", styles['Normal']))
+        story.append(Spacer(1, 12))
+
+    doc.build(story)
+    buffer.seek(0)
+    return buffer
+
+# Function to save data to Salesforce, including PDF and Status__c
+def save_to_salesforce(input_data, prediction, pdf_buffer):
+    if sf is None:
+        return "Salesforce connection not established."
+    try:
+        # Determine Status__c based on delay probability
+        status = "Flagged" if prediction["delay_probability"] > 75 else "Running"
+
+        # Prepare data for Delay_Predictor__c object
+        sf_data = {
+            "Project_Name__c": input_data["project_name"],
+            "Phase__c": input_data["phase"],
+            "Task__c": input_data["task"],
+            "Current_Progress__c": input_data["current_progress"],
+            "Task_Expected_Duration__c": input_data["task_expected_duration"],
+            "Task_Actual_Duration__c": input_data["task_actual_duration"],
+            "Workforce_Gap__c": input_data["workforce_gap"],
+            "Workforce_Skill_Level__c": input_data["workforce_skill_level"],
+            "Workforce_Shift_Hours__c": input_data["workforce_shift_hours"],
+            "Weather_Impact_Score__c": input_data["weather_impact_score"],
+            "Weather_Condition__c": input_data["weather_condition"],
+            "Weather_Forecast_Date__c": input_data["weather_forecast_date"],
+            "Project_Location__c": input_data["project_location"],
+            "Delay_Probability__c": prediction["delay_probability"],
+            "AI_Insights__c": prediction["ai_insights"],
+            "High_Risk_Phases__c": "; ".join(format_high_risk_phases(prediction["high_risk_phases"])),
+            "Status__c": status
+        }
+        logger.info(f"Attempting to save to Salesforce Delay_Predictor__c: {sf_data}")
+        
+        # Create a new record in Delay_Predictor__c
+        result = sf.Delay_Predictor__c.create(sf_data)
+        if not result["success"]:
+            logger.error(f"Salesforce save failed: {result['errors']}")
+            return f"Salesforce save failed: {result['errors']}"
+
+        # Get the record ID
+        record_id = result["id"]
+        logger.info(f"Created Salesforce record ID: {record_id}")
+
+        # Upload PDF as ContentVersion
+        pdf_data = pdf_buffer.getvalue()
+        pdf_base64 = base64.b64encode(pdf_data).decode('utf-8')
+        content_version = {
+            "Title": f"Delay_Prediction_Report_{input_data['project_name']}_{datetime.now().strftime('%Y%m%d_%H%M%S')}",
+            "PathOnClient": "project_delay_report.pdf",
+            "VersionData": pdf_base64,
+            "FirstPublishLocationId": record_id
+        }
+        cv_result = sf.ContentVersion.create(content_version)
+        if not cv_result["success"]:
+            logger.error(f"Failed to upload PDF to Salesforce: {cv_result['errors']}")
+            return f"Failed to upload PDF to Salesforce: {cv_result['errors']}"
+
+        # Get the ContentVersion ID
+        content_version_id = cv_result["id"]
+
+        # Query the ContentDocumentId from the ContentVersion
+        query = f"SELECT ContentDocumentId FROM ContentVersion WHERE Id = '{content_version_id}'"
+        query_result = sf.query(query)
+        if query_result["totalSize"] == 0:
+            logger.error(f"Failed to retrieve ContentDocumentId for ContentVersion {content_version_id}")
+            return "Failed to retrieve ContentDocumentId for the ContentVersion"
+        content_document_id = query_result["records"][0]["ContentDocumentId"]
+
+        # Construct the Salesforce URL for the ContentDocument
+        pdf_url = f"{sf_instance_url}/sfc/servlet.shepherd/document/download/{content_document_id}"
+        logger.info(f"Generated PDF URL: {pdf_url}")
+
+        # Update the Delay_Predictor__c record with the PDF URL
+        update_result = sf.Delay_Predictor__c.update(record_id, {"PDF_Report__c": pdf_url})
+        if update_result != 204:
+            logger.error(f"Failed to update PDF_Report__c with URL: {pdf_url}")
+            return f"Failed to update PDF_Report__c field: {update_result}"
+
+        return None
+    except Exception as e:
+        logger.error(f"Error saving to Salesforce: {str(e)}")
+        return f"Error saving to Salesforce: {str(e)}"
+
+# Input form
+with st.form("project_form"):
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        project_name = st.text_input("Project Name")
+        phase = st.selectbox("Phase", [""] + ["Planning", "Design", "Construction"], index=0, key="phase_select")
+        
+        if phase != st.session_state.phase:
+            st.session_state.phase = phase
+            st.session_state.task = ""
+        task_options_list = [""] + task_options.get(phase, []) if phase else [""]
+        task = st.selectbox("Task", task_options_list, index=0, key="task_select")
+        current_progress = st.number_input("Current Progress (%)", min_value=0.0, max_value=100.0, step=1.0, value=0.0)
+        task_expected_duration = st.number_input("Task Expected Duration (days)", min_value=0, step=1, value=0)
+        task_actual_duration = st.number_input("Task Actual Duration (days)", min_value=0, step=1, value=0)
+    
+    with col2:
+        workforce_gap = st.number_input("Workforce Gap (%)", min_value=0.0, max_value=100.0, step=1.0, value=0.0)
+        workforce_skill_level = st.selectbox("Workforce Skill Level", ["", "Low", "Medium", "High"], index=0)
+        workforce_shift_hours = st.number_input("Workforce Shift Hours", min_value=0, step=1, value=0)
+        st.write(f"**Selected Shift Hours**: {workforce_shift_hours}")
+        project_location = st.text_input("Project Location (City)", placeholder="e.g., New York")
+        weather_forecast_date = st.date_input("Weather Forecast Date", min_value=datetime(2025, 1, 1), value=None)
+    
+    submit_button = st.form_submit_button("Fetch Weather and Predict Delay")
+
+# Process form submission
+if submit_button:
+    logger.info("Processing form submission")
+    input_data = {
+        "project_name": project_name,
+        "phase": phase,
+        "task": task,
+        "current_progress": current_progress,
+        "task_expected_duration": task_expected_duration,
+        "task_actual_duration": task_actual_duration,
+        "workforce_gap": workforce_gap,
+        "workforce_skill_level": workforce_skill_level,
+        "workforce_shift_hours": workforce_shift_hours,
+        "weather_impact_score": 0,  # Placeholder, to be updated
+        "weather_condition": "",    # Placeholder, to be updated
+        "weather_forecast_date": weather_forecast_date.strftime("%Y-%m-%d") if weather_forecast_date else "",
+        "project_location": project_location
+    }
+    
+    # Validate inputs (excluding weather fields initially)
+    error = validate_inputs(input_data)
+    if error and not error.startswith("Please select or fill in weather"):
+        st.error(error)
+        logger.error(f"Validation error: {error}")
+    else:
+        # Fetch weather data
+        if project_location and weather_forecast_date:
+            weather_data, weather_error = fetch_weather_data(project_location, input_data["weather_forecast_date"])
+            if weather_error:
+                st.error(weather_error.get("error", "Unknown weather error"))
+                logger.error(weather_error.get("error", "Unknown weather error"))
+                input_data["weather_impact_score"] = 50  # Fallback value
+                input_data["weather_condition"] = "Unknown"
+            else:
+                input_data["weather_impact_score"] = weather_data["weather_impact_score"]
+                input_data["weather_condition"] = weather_data["weather_condition"]
+                st.write(f"**Weather Data for {project_location} on {input_data['weather_forecast_date']}**:")
+                st.write(f"- Condition: {weather_data['weather_condition']}")
+                st.write(f"- Impact Score: {weather_data['weather_impact_score']}")
+                st.write(f"- Temperature: {weather_data['temperature']}°C")
+                st.write(f"- Humidity: {weather_data['humidity']}%")
+                st.session_state.weather_data = weather_data
+        else:
+            st.error("Please provide a project location and weather forecast date.")
+            logger.error("Project location or weather forecast date missing")
+            input_data["weather_impact_score"] = 50  # Fallback value
+            input_data["weather_condition"] = "Unknown"
+        
+        # Re-validate with weather data
+        error = validate_inputs(input_data)
+        if error:
+            st.error(error)
+            logger.error(f"Validation error: {error}")
+        else:
+            with st.spinner("Generating predictions and AI insights..."):
+                try:
+                    prediction = predict_delay(input_data)
+                except Exception as e:
+                    st.error(f"Prediction failed: {str(e)}")
+                    logger.error(f"Prediction failed: {str(e)}")
+                    prediction = {"error": str(e)}
+            
+            if "error" in prediction:
+                st.error(prediction["error"])
+            else:
+                st.subheader("Prediction Results")
+                st.write(f"**Delay Probability**: {prediction['delay_probability']:.2f}%")
+                st.write("**High Risk Phases**:")
+                for line in format_high_risk_phases(prediction['high_risk_phases']):
+                    st.write(line)
+                st.write(f"**AI Insights**: {prediction['ai_insights']}")
+                st.write(f"**Weather Condition**: {prediction['weather_condition']}")
+                
+                # Generate Chart.js heatmap
+                chart_config = generate_heatmap(prediction['delay_probability'], f"{phase}: {task}")
+                chart_id = f"chart-{hash(str(chart_config))}"
+                chart_html = f"""
+                <canvas id="{chart_id}" style="max-height: 200px; max-width: 600px;"></canvas>
+                <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+                <script>
+                    try {{
+                        const ctx = document.getElementById('{chart_id}').getContext('2d');
+                        new Chart(ctx, {json.dumps(chart_config)});
+                    }} catch (e) {{
+                        console.error('Chart.js failed: ' + e);
+                    }}
+                </script>
+                """
+                try:
+                    components.html(chart_html, height=250)
+                    logger.info("Chart.js heatmap rendered")
+                except Exception as e:
+                    logger.error(f"Chart.js rendering failed: {str(e)}")
+                    st.error("Failed to render heatmap; please check your browser settings.")
+                
+                # Generate matplotlib figure for PDF
+                fig, ax = plt.subplots(figsize=(8, 2))
+                color = 'red' if prediction['delay_probability'] > 75 else 'yellow' if prediction['delay_probability'] > 50 else 'green'
+                ax.barh([f"{phase}: {task}"], [prediction['delay_probability']], color=color, edgecolor='black')
+                ax.set_xlim(0, 100)
+                ax.set_xlabel("Delay Probability (%)")
+                ax.set_title("Delay Risk Heatmap")
+                plt.tight_layout()
+                
+                # Generate Gantt chart
+                gantt_fig = generate_gantt_chart(input_data, prediction)
+                if gantt_fig:
+                    st.plotly_chart(gantt_fig, use_container_width=True)
+                    logger.info("Gantt chart rendered")
+                
+                pdf_buffer = generate_pdf(input_data, prediction, fig, gantt_fig)
+                plt.close(fig)
+                st.download_button(
+                    label="Download Prediction Report (PDF)",
+                    data=pdf_buffer,
+                    file_name="project_delay_report.pdf",
+                    mime="application/pdf"
+                )
+                
+                # Save to Salesforce, including PDF
+                sf_error = save_to_salesforce(input_data, prediction, pdf_buffer)
+                if sf_error:
+                    st.error(sf_error)
+                    logger.error(f"Salesforce error: {sf_error}")
+                else:
+                    st.success("Prediction data and PDF successfully saved to Salesforce!")
+                    logger.info("Data and PDF saved to Salesforce")
+                
+                st.session_state.prediction = prediction
+                st.session_state.input_data = input_data

model.py

@@ -0,0 +1,303 @@
+import logging
+from typing import Dict, List
+import torch
+import torch.nn as nn
+import numpy as np
+import pickle
+from sklearn.preprocessing import StandardScaler
+from datetime import datetime, timedelta
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# LSTM Model Definition (must match training script)
+class DelayPredictor(nn.Module):
+    def __init__(self, input_size, hidden_size, num_layers):
+        super(DelayPredictor, self).__init__()
+        self.hidden_size = hidden_size
+        self.num_layers = num_layers
+        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
+        self.attention = nn.Linear(hidden_size, 1)
+        self.fc = nn.Linear(hidden_size, 1)
+        self.sigmoid = nn.Sigmoid()
+
+    def forward(self, x):
+        lstm_out, _ = self.lstm(x)
+        attn_weights = torch.softmax(self.attention(lstm_out).squeeze(-1), dim=1)
+        context = torch.bmm(attn_weights.unsqueeze(1), lstm_out).squeeze(1)
+        out = self.fc(context)
+        return self.sigmoid(out) * 100
+
+# Load model and scaler
+try:
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = DelayPredictor(input_size=7, hidden_size=64, num_layers=2).to(device)
+    model.load_state_dict(torch.load("models/delay_model.pth", map_location=device))
+    model.eval()
+    with open("models/scaler.pkl", "rb") as f:
+        scaler = pickle.load(f)
+    logger.info("LSTM model and scaler loaded successfully")
+except Exception as e:
+    logger.error(f"Failed to load model or scaler: {str(e)}")
+    model = None
+    scaler = None
+
+def get_weather_condition(score: int) -> str:
+    """Map weather impact score (0-100) to descriptive weather condition."""
+    if score <= 10:
+        return "Sunny"
+    elif score <= 30:
+        return "Partly Cloudy"
+    elif score <= 50:
+        return "Cloudy"
+    elif score <= 70:
+        return "Light Rain"
+    elif score <= 85:
+        return "Heavy Rain"
+    else:
+        return "Severe Storm"
+
+def call_ai_model_for_insights(input_data: Dict, delay_risk: float) -> List[str]:
+    """
+    Generate detailed hardcoded insights based on input data and delay risk.
+    Includes a 2-week risk alert if weather_forecast_date is within 14 days.
+    Returns 3-5 prioritized, phase/task-specific insights.
+    """
+    logger.info("Generating detailed hardcoded AI insights")
+    phase = input_data.get("phase", "")
+    task = input_data.get("task", "")
+    current_progress = input_data.get("current_progress", 0)
+    expected_duration = input_data.get("task_expected_duration", 0)
+    actual_duration = input_data.get("task_actual_duration", 0)
+    workforce_gap = input_data.get("workforce_gap", 0)
+    skill_level = input_data.get("workforce_skill_level", "").lower()
+    shift_hours = input_data.get("workforce_shift_hours", 0)
+    weather_score = input_data.get("weather_impact_score", 0)
+    weather_condition = input_data.get("weather_condition", get_weather_condition(weather_score))
+    project_location = input_data.get("project_location", "Unknown")
+    weather_forecast_date = input_data.get("weather_forecast_date", "")
+
+    # Initialize insights with scores for prioritization
+    insights = []
+
+    # Helper function to add insight with priority score
+    def add_insight(message: str, priority: float):
+        insights.append((message, priority))
+
+    # 2-week risk alert
+    try:
+        forecast_date = datetime.strptime(weather_forecast_date, "%Y-%m-%d")
+        current_date = datetime(2025, 5, 26)  # Fixed date as per system
+        two_weeks_later = current_date + timedelta(days=14)
+        if current_date <= forecast_date <= two_weeks_later:
+            if delay_risk > 75 or weather_score > 75:
+                add_insight(
+                    f"⚠️ Critical 2-Week Risk Alert: High risk of delay for {phase}: {task} in {project_location} by {weather_forecast_date} due to {'severe weather' if weather_score > 75 else 'high delay probability'}. Implement contingency plans immediately.",
+                    1.2
+                )
+            elif delay_risk > 50 or weather_score > 50:
+                add_insight(
+                    f"⚠️ 2-Week Risk Alert: Moderate risk of delay for {phase}: {task} in {project_location} by {weather_forecast_date}. Monitor closely and prepare mitigation measures.",
+                    1.1
+                )
+    except ValueError:
+        logger.warning("Invalid weather_forecast_date format; skipping 2-week risk alert")
+
+    # Delay risk-based insights
+    if delay_risk > 75:
+        add_insight(f"Urgent: High delay risk detected for {phase}: {task} in {project_location}. Take immediate action.", 1.0)
+    elif delay_risk > 50:
+        add_insight(f"Monitor {phase}: {task} closely in {project_location} to prevent delays.", 0.9)
+    elif delay_risk > 25:
+        add_insight(f"Maintain steady progress for {phase}: {task} in {project_location}.", 0.7)
+    else:
+        add_insight(f"Optimize resources for {phase}: {task} in {project_location} to maintain schedule.", 0.6)
+
+    # Weather-specific insights
+    if weather_score > 85:
+        add_insight(f"Critical: Severe storm forecast in {project_location} for {phase}: {task}. Consider halting outdoor activities.", 1.1)
+    elif weather_score > 70:
+        add_insight(f"Reschedule outdoor tasks for {phase}: {task} in {project_location} due to heavy rain forecast.", 1.0)
+    elif weather_score > 50:
+        add_insight(f"Shift to indoor or weather-resistant tasks for {phase}: {task} in {project_location} due to light rain.", 0.9)
+    elif weather_score > 30:
+        add_insight(f"Monitor cloudy conditions in {project_location} for {phase}: {task} to avoid unexpected delays.", 0.7)
+    else:
+        add_insight(f"Proceed with {phase}: {task} in {project_location} under favorable weather conditions.", 0.6)
+
+    # Phase/task-specific insights
+    task_specific = {
+        "Planning": {
+            "Define Scope": f"Ensure stakeholder alignment for Planning: Define Scope in {project_location}, considering weather impacts.",
+            "Resource Allocation": f"Secure budget and resources early for Planning: Resource Allocation in {project_location}.",
+            "Permit Acquisition": f"Expedite permits for Planning: Permit Acquisition in {project_location} to avoid weather-related delays."
+        },
+        "Design": {
+            "Architectural Drafting": f"Engage architects early for Design: Architectural Drafting in {project_location}, accounting for weather.",
+            "Engineering Analysis": f"Hire additional engineers for Design: Engineering Analysis in {project_location} to meet deadlines.",
+            "Design Review": f"Schedule thorough reviews for Design: Design Review in {project_location}, considering forecast."
+        },
+        "Construction": {
+            "Foundation Work": f"Optimize material delivery for Construction: Foundation Work in {project_location}, avoiding {weather_condition.lower()}.",
+            "Structural Build": f"Ensure equipment availability for Construction: Structural Build in {project_location} under {weather_condition.lower()}.",
+            "Utility Installation": f"Coordinate subcontractors for Construction: Utility Installation in {project_location}, monitoring weather."
+        }
+    }
+    if phase in task_specific and task in task_specific[phase]:
+        add_insight(task_specific[phase][task], 0.8)
+
+    # Workforce-based insights
+    if workforce_gap > 30:
+        add_insight(f"Urgently hire subcontractors in {project_location} to address {workforce_gap}% workforce shortage.", 1.0)
+    elif workforce_gap > 15:
+        add_insight(f"Recruit additional workers in {project_location} to reduce {workforce_gap}% workforce gap.", 0.9)
+    elif workforce_gap > 5:
+        add_insight(f"Consider temporary staff in {project_location} to address minor workforce gap.", 0.7)
+
+    if skill_level == "low":
+        add_insight(f"Provide training in {project_location} to improve low skill levels for {phase}: {task}.", 0.9)
+    elif skill_level == "medium" and delay_risk > 50:
+        add_insight(f"Upskill workforce in {project_location} for efficiency in {phase}: {task}.", 0.8)
+    elif skill_level == "high" and delay_risk < 25:
+        add_insight(f"Leverage high skill levels in {project_location} to maintain {phase}: {task} progress.", 0.6)
+
+    if shift_hours < 6:
+        add_insight(f"Extend shift hours beyond {shift_hours} in {project_location} to meet {phase}: {task} deadlines.", 0.9)
+    elif shift_hours < 8 and delay_risk > 50:
+        add_insight(f"Increase shift hours to 8 in {project_location} for {phase}: {task}.", 0.8)
+    elif shift_hours > 10:
+        add_insight(f"Balance shifts in {project_location} to prevent burnout during {phase}: {task}.", 0.7)
+
+    # Progress and duration-based insights
+    if expected_duration > 0 and actual_duration > expected_duration:
+        overrun_pct = ((actual_duration - expected_duration) / expected_duration) * 100
+        if overrun_pct > 20:
+            add_insight(f"Address significant duration overrun ({overrun_pct:.1f}%) for {phase}: {task} in {project_location}.", 1.0)
+        elif overrun_pct > 10:
+            add_insight(f"Review scheduling to address {overrun_pct:.1f}% overrun in {phase}: {task} in {project_location}.", 0.8)
+
+    if expected_duration > 0:
+        expected_progress = min((actual_duration / expected_duration) * 100, 100)
+        if current_progress < expected_progress * 0.8:
+            add_insight(f"Accelerate task progress for {phase}: {task} in {project_location} to align with schedule.", 0.9)
+        elif current_progress < 50 and delay_risk > 50:
+            add_insight(f"Increase resources to boost {current_progress}% progress in {phase}: {task} in {project_location}.", 0.8)
+
+    # Edge cases
+    if workforce_gap >= 90:
+        add_insight(f"Critical: Halt non-essential tasks in {project_location} until workforce gap for {phase}: {task} is resolved.", 1.1)
+    if current_progress == 0 and delay_risk > 50:
+        add_insight(f"Initiate {phase}: {task} in {project_location} immediately to avoid further delays.", 1.0)
+    if expected_duration == 0 or actual_duration == 0:
+        add_insight(f"Provide accurate duration estimates for {phase}: {task} in {project_location} for reliable predictions.", 0.7)
+    if weather_score > 50 and phase == "Construction":
+        add_insight(f"Prepare contingency plans for {phase}: {task} in {project_location} due to adverse weather forecast.", 0.95)
+
+    # Sort insights by priority and select top 3-5
+    insights.sort(key=lambda x: x[1], reverse=True)
+    selected_insights = [insight[0] for insight in insights[:5]]
+
+    logger.info(f"Generated insights: {selected_insights}")
+    return selected_insights or [f"No significant delay factors detected for {phase}: {task} in {project_location}."]
+
+def predict_delay(input_data: Dict) -> Dict:
+    """
+    Predict delay probability using LSTM model.
+    Inputs: Project task data (phase, progress, duration, workforce, weather).
+    Outputs: Delay probability, AI insights, high-risk phases, weather condition.
+    """
+    logger.info("Starting LSTM delay prediction")
+    if model is None or scaler is None:
+        logger.error("Model or scaler not loaded; falling back to default")
+        return {
+            "project": input_data.get("project_name", "Unnamed Project"),
+            "phase": input_data.get("phase", ""),
+            "task": input_data.get("task", ""),
+            "delay_probability": 50.0,
+            "ai_insights": "Model unavailable; please check deployment.",
+            "high_risk_phases": [],
+            "weather_condition": "Unknown"
+        }
+
+    phase = input_data.get("phase", "")
+    task = input_data.get("task", "")
+    weather_condition = input_data.get("weather_condition", get_weather_condition(input_data.get("weather_impact_score", 0)))
+
+    # Prepare input features
+    phase_mapping = {"Planning": 0, "Design": 1, "Construction": 2}
+    skill_mapping = {"Low": 0, "Medium": 1, "High": 2}
+    try:
+        features = np.array([[
+            input_data.get("current_progress", 0),
+            input_data.get("task_expected_duration", 0),
+            input_data.get("task_actual_duration", 0),
+            input_data.get("workforce_gap", 0),
+            input_data.get("weather_impact_score", 0),
+            skill_mapping.get(input_data.get("workforce_skill_level", "Medium"), 1),
+            phase_mapping.get(phase, 0)
+        ]])
+    except KeyError as e:
+        logger.error(f"Invalid input data: {str(e)}")
+        return {
+            "project": input_data.get("project_name", "Unnamed Project"),
+            "phase": phase,
+            "task": task,
+            "delay_probability": 50.0,
+            "ai_insights": f"Invalid input: {str(e)}",
+            "high_risk_phases": [],
+            "weather_condition": weather_condition
+        }
+
+    # Standardize and reshape
+    try:
+        features_scaled = scaler.transform(features)
+        features_tensor = torch.tensor(features_scaled.reshape(1, 1, -1), dtype=torch.float32).to(device)
+    except Exception as e:
+        logger.error(f"Feature preprocessing failed: {str(e)}")
+        return {
+            "project": input_data.get("project_name", "Unnamed Project"),
+            "phase": phase,
+            "task": task,
+            "delay_probability": 50.0,
+            "ai_insights": f"Preprocessing error: {str(e)}",
+            "high_risk_phases": [],
+            "weather_condition": weather_condition
+        }
+
+    # Predict
+    with torch.no_grad():
+        delay_risk = model(features_tensor).cpu().numpy().item()
+        delay_risk = round(max(0, min(delay_risk, 100)), 1)
+
+    # Generate high_risk_phases
+    task_options = {
+        "Planning": ["Define Scope", "Resource Allocation", "Permit Acquisition"],
+        "Design": ["Architectural Drafting", "Engineering Analysis", "Design Review"],
+        "Construction": ["Foundation Work", "Structural Build", "Utility Installation"]
+    }
+    high_risk_phases = []
+    if phase in task_options:
+        for t in task_options[phase]:
+            task_risk = delay_risk
+            if t != task:
+                task_risk = min(max(task_risk + (hash(t) % 10 - 5), 0), 100)
+            high_risk_phases.append({
+                "phase": phase,
+                "task": t,
+                "risk": round(task_risk, 1)
+            })
+
+    # Generate insights
+    insights = call_ai_model_for_insights(input_data, delay_risk)
+
+    logger.info(f"Prediction completed: Delay risk = {delay_risk:.1f}%")
+    return {
+        "project": input_data.get("project_name", "Unnamed Project"),
+        "phase": phase,
+        "task": task,
+        "delay_probability": delay_risk,
+        "ai_insights": "; ".join(insights) if insights else "No significant delay factors detected.",
+        "high_risk_phases": high_risk_phases,
+        "weather_condition": weather_condition
+    }

requirements.txt

@@ -0,0 +1,12 @@
+streamlit==1.39.0
+pandas==2.2.3
+numpy==1.26.4
+matplotlib==3.9.2
+requests==2.32.3
+simple-salesforce==1.12.6
+reportlab==4.2.5
+python-dateutil==2.9.0
+scikit-learn==1.5.2
+torch==2.4.1
+plotly==5.24.1
+kaleido==0.2.1

utils.py

@@ -0,0 +1,57 @@
+import matplotlib.pyplot as plt
+
+def validate_inputs(input_data):
+    """
+    Validate input data for required fields and ranges.
+    """
+    required_fields = [
+        "project_name", "phase", "task", "current_progress",
+        "task_expected_duration", "task_actual_duration", "workforce_gap",
+        "workforce_skill_level", "workforce_shift_hours", "weather_impact_score",
+        "weather_condition", "weather_forecast_date", "project_location"
+    ]
+    for field in required_fields:
+        if not input_data[field]:
+            return f"Please select or fill in {field.replace('_', ' ').lower()}"
+    if not (0 <= input_data["current_progress"] <= 100):
+        return "Current progress must be between 0 and 100"
+    if not (0 <= input_data["workforce_gap"] <= 100):
+        return "Workforce gap must be between 0 and 100"
+    if not (0 <= input_data["weather_impact_score"] <= 100):
+        return "Weather impact score must be between 0 and 100"
+    return None
+
+def generate_heatmap(delay_probability, label):
+    """
+    Generate a Chart.js bar chart configuration to visualize delay probability.
+    Returns a Chart.js configuration dictionary.
+    """
+    color = '#FF0000' if delay_probability > 75 else '#FFFF00' if delay_probability > 50 else '#00FF00'
+    chart_config = {
+        "type": "bar",
+        "data": {
+            "labels": [label],
+            "datasets": [{
+                "label": "Delay Probability (%)",
+                "data": [delay_probability],
+                "backgroundColor": [color],
+                "borderColor": ["#000000"],
+                "borderWidth": 1
+            }]
+        },
+        "options": {
+            "indexAxis": "y",
+            "scales": {
+                "x": {
+                    "beginAtZero": True,
+                    "max": 100,
+                    "title": {"display": True, "text": "Delay Probability (%)"}
+                },
+                "y": {"title": {"display": True, "text": "Task"}}
+            },
+            "plugins": {
+                "title": {"display": True, "text": "Delay Risk Heatmap"}
+            }
+        }
+    }
+    return chart_config