Upload 3 files

app.py

@@ -0,0 +1,186 @@
+import streamlit as st
+import pandas as pd
+import matplotlib.pyplot as plt
+from datetime import datetime
+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
+
+# Streamlit app configuration
+st.set_page_config(page_title="Delay 🚀", layout="wide")
+
+# 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 for phase and task
+if 'phase' not in st.session_state:
+    st.session_state.phase = ""
+if 'task' not in st.session_state:
+    st.session_state.task = ""
+
+# 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 PDF
+def generate_pdf(input_data, prediction, heatmap_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']}"
+    ]
+    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']))
+    # Format high_risk_phases for PDF
+    high_risk_text = "<br/>".join(format_high_risk_phases(prediction['high_risk_phases']))
+    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']))
+    # Save heatmap figure to BytesIO as PNG
+    img_buffer = BytesIO()
+    heatmap_fig.savefig(img_buffer, format='png', bbox_inches='tight')
+    img_buffer.seek(0)
+    # Embed image in PDF (scale to fit page width)
+    story.append(Image(img_buffer, width=6*inch, height=2*inch))
+    plt.close(heatmap_fig)  # Close figure to free memory
+
+    doc.build(story)
+    buffer.seek(0)
+    return buffer
+
+# 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")
+        
+        # Update task options based on phase
+        if phase != st.session_state.phase:
+            st.session_state.phase = phase
+            st.session_state.task = ""  # Reset task when phase changes
+        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)
+        task_expected_duration = st.number_input("Task Expected Duration (days)", min_value=0, step=1)
+        task_actual_duration = st.number_input("Task Actual Duration (days)", min_value=0, step=1)
+    
+    with col2:
+        workforce_gap = st.number_input("Workforce Gap (%)", min_value=0.0, max_value=100.0, step=1.0)
+        workforce_skill_level = st.selectbox("Workforce Skill Level", ["Low", "Medium", "High"], index=1)
+        workforce_shift_hours = st.number_input("Workforce Shift Hours", min_value=0, step=1, value=8)
+        # Debug output for shift hours
+        st.write(f"**Selected Shift Hours**: {workforce_shift_hours}")
+        weather_impact_score = st.number_input("Weather Impact Score (0-100)", min_value=0, max_value=100, step=1)
+        # Display computed weather condition
+        weather_condition = get_weather_condition(weather_impact_score)
+        st.write(f"**Weather Condition**: {weather_condition}")
+        weather_forecast_date = st.date_input("Weather Forecast Date", min_value=datetime(2025, 1, 1))
+    
+    submit_button = st.form_submit_button("Predict Delay")
+
+# Process form submission
+if submit_button:
+    # Prepare input data
+    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": weather_impact_score,
+        "weather_condition": weather_condition,
+        "weather_forecast_date": weather_forecast_date.strftime("%Y-%m-%d")
+    }
+    
+    # Validate inputs
+    error = validate_inputs(input_data)
+    if error:
+        st.error(error)
+    else:
+        # Get prediction
+        with st.spinner("Predicting..."):
+            prediction = predict_delay(input_data)
+        
+        if "error" in prediction:
+            st.error(prediction["error"])
+        else:
+            # Display results
+            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 and display heatmap
+            fig = generate_heatmap(prediction['delay_probability'], f"{phase}: {task}")
+            st.pyplot(fig)
+            
+            # Generate PDF with heatmap and provide download link
+            pdf_buffer = generate_pdf(input_data, prediction, fig)
+            st.download_button(
+                label="Download Prediction Report (PDF)",
+                data=pdf_buffer,
+                file_name="project_delay_report.pdf",
+                mime="application/pdf"
+            )
+            
+            # Store prediction in session state
+            st.session_state.prediction = prediction
+            st.session_state.input_data = input_data

model.py

@@ -0,0 +1,131 @@
+def get_weather_condition(score):
+    """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 predict_delay(input_data):
+    """
+    Predict delay probability based on project task data.
+    Uses task duration, progress, workforce info, and weather impact.
+    """
+    phase = input_data.get("phase", "")
+    task = input_data.get("task", "")
+    expected_duration = input_data.get("task_expected_duration", 0)
+    actual_duration = input_data.get("task_actual_duration", 0)
+    
+    current_progress = input_data.get("current_progress", 0)        # in %
+    workforce_gap_pct = input_data.get("workforce_gap", 0)          # in %
+    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)       # 0-100 scale
+
+    # Auto-set weather condition if missing or inconsistent
+    weather_condition = input_data.get("weather_condition", "")
+    if not weather_condition:
+        weather_condition = get_weather_condition(weather_score)
+
+    # Task options for phase (hardcoded to match app.py)
+    task_options = {
+        "Planning": ["Define Scope", "Resource Allocation", "Permit Acquisition"],
+        "Design": ["Architectural Drafting", "Engineering Analysis", "Design Review"],
+        "Construction": ["Foundation Work", "Structural Build", "Utility Installation"]
+    }
+
+    delay_risk = 0
+    insights = []
+
+    # 1. Duration overrun risk
+    if expected_duration > 0 and actual_duration > expected_duration:
+        overrun_pct = ((actual_duration - expected_duration) / expected_duration) * 100
+        delay_risk += min(overrun_pct, 30)
+        insights.append(f"Actual duration is {overrun_pct:.1f}% over expected.")
+
+    # 2. Progress lag risk
+    if expected_duration > 0 and current_progress >= 0:
+        expected_progress = (actual_duration / expected_duration) * 100
+        if current_progress < expected_progress:
+            progress_gap = expected_progress - current_progress
+            delay_risk += min(progress_gap, 25)
+            insights.append(f"Current progress ({current_progress}%) lags behind expected ({expected_progress:.1f}%).")
+
+    # 3. Workforce gap impact
+    if workforce_gap_pct > 0:
+        delay_risk += min(workforce_gap_pct * 0.5, 20)
+        insights.append(f"Workforce gap at {workforce_gap_pct}% reduces productivity.")
+
+    # 4. Skill level effect
+    if skill_level == "low":
+        delay_risk += 15
+        insights.append("Low skill level may reduce task efficiency.")
+    elif skill_level == "medium":
+        delay_risk += 7
+
+    # 5. Shift hours effect
+    if shift_hours < 8:
+        penalty = (8 - shift_hours) * 3
+        delay_risk += penalty
+        insights.append(f"Reduced shift hours ({shift_hours}h) add {penalty:.1f}% to delay risk.")
+    elif shift_hours > 8:
+        bonus = (shift_hours - 8) * 2
+        delay_risk -= min(bonus, 10)
+        insights.append(f"Extended shift hours ({shift_hours}h) reduce delay risk by {min(bonus, 10):.1f}%.")
+    else:
+        insights.append("Standard shift hours (8h) have neutral impact.")
+
+    # 6. Weather impact effect
+    if weather_score > 50:
+        delay_risk += min(weather_score / 2, 20)
+        insights.append(f"High weather impact score ({weather_score}) — current condition: {weather_condition}.")
+
+    # Ensure delay_risk is between 0 and 100
+    delay_risk = max(0, min(delay_risk, 100))
+
+    # Generate high_risk_phases for all tasks in the phase
+    high_risk_phases = []
+    if phase in task_options:
+        for t in task_options[phase]:
+            task_risk = delay_risk
+            # Adjust risk slightly for other tasks (simulate variation)
+            if t != task:
+                task_risk = min(max(task_risk + (hash(t) % 10 - 5), 0), 100)  # ±5% variation
+            high_risk_phases.append({
+                "phase": phase,
+                "task": t,
+                "risk": round(task_risk, 1)
+            })
+
+    # Enhanced mitigation strategies based on risk level
+    mitigation_strategies = []
+    if delay_risk > 75:
+        mitigation_strategies.append("Urgent: Allocate additional resources and expedite critical tasks.")
+        if phase == "Construction":
+            mitigation_strategies.append("Secure backup equipment and materials to counter weather delays.")
+        elif phase == "Planning":
+            mitigation_strategies.append("Fast-track permit approvals and stakeholder alignment.")
+    elif delay_risk > 50:
+        mitigation_strategies.append("Moderate risk: Increase workforce or extend shift hours.")
+        if weather_score > 50:
+            mitigation_strategies.append("Plan indoor tasks or weather-resistant schedules.")
+    else:
+        mitigation_strategies.append("Low risk: Maintain current plan, monitor progress closely.")
+    insights.extend(mitigation_strategies)
+
+    return {
+        "project": input_data.get("project_name", "Unnamed Project"),
+        "phase": phase,
+        "task": task,
+        "delay_probability": round(delay_risk, 1),
+        "ai_insights": "; ".join(insights) if insights else "No significant delay factors detected.",
+        "high_risk_phases": high_risk_phases,
+        "weather_condition": weather_condition
+    }

utils.py

@@ -0,0 +1,36 @@
+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_shift_hours", "weather_impact_score", "weather_condition",
+        "weather_forecast_date"
+    ]
+    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 bar chart to visualize delay probability.
+    Returns the matplotlib figure object.
+    """
+    fig, ax = plt.subplots(figsize=(8, 2))
+    color = 'red' if delay_probability > 75 else 'yellow' if delay_probability > 50 else 'green'
+    ax.barh([label], [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()
+    return fig