Update model.py

model.py

@@ -5,10 +5,25 @@ from typing import Dict, List
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
+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, bypassing T5-Small.
-    Returns 3-5 prioritized, phase/task-specific insights tailored to conditions.
+    Generate detailed hardcoded insights based on input data and delay risk.
+    Returns 3-5 prioritized, phase/task-specific insights tailored to conditions, with enhanced weather focus.
     """
     logger.info("Generating detailed hardcoded AI insights")
     phase = input_data.get("phase", "")
@@ -19,7 +34,9 @@ def call_ai_model_for_insights(input_data: Dict, delay_risk: float) -> List[str]
     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_condition = input_data.get("weather_condition", "").lower()
+    weather_score = input_data.get("weather_impact_score", 0)
+    weather_condition = input_data.get("weather_condition", get_weather_condition(weather_score))
+    city = input_data.get("city", "Unknown")
 
     # Initialize insights with scores for prioritization
     insights = []
@@ -30,30 +47,42 @@ def call_ai_model_for_insights(input_data: Dict, delay_risk: float) -> List[str]
 
     # Delay risk-based insights
     if delay_risk > 75:
-        add_insight(f"Urgent: Accelerate {phase}: {task} to mitigate high delay risk", 1.0)
+        add_insight(f"Urgent: High delay risk detected for {phase}: {task} in {city}. Take immediate action.", 1.0)
     elif delay_risk > 50:
-        add_insight(f"Monitor {phase}: {task} closely to prevent delays", 0.9)
+        add_insight(f"Monitor {phase}: {task} closely in {city} to prevent delays.", 0.9)
     elif delay_risk > 25:
-        add_insight(f"Maintain current pace for {phase}: {task}", 0.7)
+        add_insight(f"Maintain steady progress for {phase}: {task} in {city}.", 0.7)
+    else:
+        add_insight(f"Optimize resources for {phase}: {task} in {city} to maintain schedule.", 0.6)
+
+    # Weather-specific insights (enhanced)
+    if weather_score > 85:
+        add_insight(f"Critical: Severe storm forecast in {city} for {phase}: {task}. Consider halting outdoor activities.", 1.1)
+    elif weather_score > 70:
+        add_insight(f"Reschedule outdoor tasks for {phase}: {task} in {city} 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 {city} due to light rain.", 0.9)
+    elif weather_score > 30:
+        add_insight(f"Monitor cloudy conditions in {city} for {phase}: {task} to avoid unexpected delays.", 0.7)
     else:
-        add_insight(f"Optimize resource allocation for {phase}: {task}", 0.6)
+        add_insight(f"Proceed with {phase}: {task} in {city} under favorable weather conditions.", 0.6)
 
     # Phase/task-specific insights
     task_specific = {
         "Planning": {
-            "Define Scope": "Ensure clear stakeholder alignment for Planning: Define Scope",
-            "Resource Allocation": "Secure budget approvals early for Planning: Resource Allocation",
-            "Permit Acquisition": "Secure permits early for Planning: Permit Acquisition"
+            "Define Scope": f"Ensure stakeholder alignment for Planning: Define Scope in {city}, considering weather impacts.",
+            "Resource Allocation": f"Secure budget and resources early for Planning: Resource Allocation in {city}.",
+            "Permit Acquisition": f"Expedite permits for Planning: Permit Acquisition in {city} to avoid weather-related delays."
         },
         "Design": {
-            "Architectural Drafting": "Engage architects early for Design: Architectural Drafting",
-            "Engineering Analysis": "Hire additional engineers for Design: Engineering Analysis",
-            "Design Review": "Schedule thorough reviews for Design: Design Review"
+            "Architectural Drafting": f"Engage architects early for Design: Architectural Drafting in {city}, accounting for weather.",
+            "Engineering Analysis": f"Hire additional engineers for Design: Engineering Analysis in {city} to meet deadlines.",
+            "Design Review": f"Schedule thorough reviews for Design: Design Review in {city}, considering forecast."
         },
         "Construction": {
-            "Foundation Work": "Optimize material delivery for Construction: Foundation Work",
-            "Structural Build": "Ensure equipment availability for Construction: Structural Build",
-            "Utility Installation": "Coordinate subcontractors for Construction: Utility Installation"
+            "Foundation Work": f"Optimize material delivery for Construction: Foundation Work in {city}, avoiding {weather_condition.lower()}.",
+            "Structural Build": f"Ensure equipment availability for Construction: Structural Build in {city} under {weather_condition.lower()}.",
+            "Utility Installation": f"Coordinate subcontractors for Construction: Utility Installation in {city}, monitoring weather."
         }
     }
     if phase in task_specific and task in task_specific[phase]:
@@ -61,68 +90,62 @@ def call_ai_model_for_insights(input_data: Dict, delay_risk: float) -> List[str]
 
     # Workforce-based insights
     if workforce_gap > 30:
-        add_insight(f"Hire subcontractors immediately to address {workforce_gap}% workforce shortage", 1.0)
+        add_insight(f"Urgently hire subcontractors in {city} to address {workforce_gap}% workforce shortage.", 1.0)
     elif workforce_gap > 15:
-        add_insight(f"Hire additional workers to reduce {workforce_gap}% workforce gap", 0.9)
+        add_insight(f"Recruit additional workers in {city} to reduce {workforce_gap}% workforce gap.", 0.9)
     elif workforce_gap > 5:
-        add_insight("Consider temporary staff to address minor workforce gap", 0.7)
+        add_insight(f"Consider temporary staff in {city} to address minor workforce gap.", 0.7)
 
     if skill_level == "low":
-        add_insight(f"Provide training to improve low skill levels for {phase}: {task}", 0.9)
+        add_insight(f"Provide training in {city} to improve low skill levels for {phase}: {task}.", 0.9)
     elif skill_level == "medium" and delay_risk > 50:
-        add_insight(f"Upskill workforce for efficiency in {phase}: {task}", 0.8)
+        add_insight(f"Upskill workforce in {city} for efficiency in {phase}: {task}.", 0.8)
     elif skill_level == "high" and delay_risk < 25:
-        add_insight("Leverage high skill levels to maintain progress", 0.6)
+        add_insight(f"Leverage high skill levels in {city} to maintain {phase}: {task} progress.", 0.6)
 
     if shift_hours < 6:
-        add_insight(f"Extend shift hours beyond {shift_hours} to meet {phase}: {task} deadlines", 0.9)
+        add_insight(f"Extend shift hours beyond {shift_hours} in {city} to meet {phase}: {task} deadlines.", 0.9)
     elif shift_hours < 8 and delay_risk > 50:
-        add_insight(f"Increase shift hours to {8} for {phase}: {task}", 0.8)
+        add_insight(f"Increase shift hours to 8 in {city} for {phase}: {task}.", 0.8)
     elif shift_hours > 10:
-        add_insight("Balance shifts to prevent burnout", 0.7)
-
-    # Weather-based insights
-    if weather_condition in ["severe storm", "heavy rain"]:
-        add_insight(f"Reschedule {phase}: {task} to avoid {weather_condition}", 1.0)
-    elif weather_condition == "light rain":
-        add_insight(f"Shift to indoor tasks during {weather_condition} for {phase}: {task}", 0.9)
-    elif weather_condition in ["cloudy", "partly cloudy"]:
-        add_insight(f"Continue monitoring {weather_condition} for {phase}: {task}", 0.7)
+        add_insight(f"Balance shifts in {city} 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 duration overrun urgently for {phase}: {task}", 1.0)
+            add_insight(f"Address significant duration overrun ({overrun_pct:.1f}%) for {phase}: {task} in {city}.", 1.0)
         elif overrun_pct > 10:
-            add_insight(f"Review scheduling to address {overrun_pct:.1f}% overrun in {phase}: {task}", 0.8)
+            add_insight(f"Review scheduling to address {overrun_pct:.1f}% overrun in {phase}: {task} in {city}.", 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} to align with schedule", 0.9)
+            add_insight(f"Accelerate task progress for {phase}: {task} in {city} 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}", 0.8)
+            add_insight(f"Increase resources to boost {current_progress}% progress in {phase}: {task} in {city}.", 0.8)
 
     # Edge cases
     if workforce_gap >= 90:
-        add_insight(f"Critical: Halt non-essential tasks until {phase}: {task} workforce gap is resolved", 1.1)
+        add_insight(f"Critical: Halt non-essential tasks in {city} until workforce gap for {phase}: {task} is resolved.", 1.1)
     if current_progress == 0 and delay_risk > 50:
-        add_insight(f"Initiate {phase}: {task} immediately to avoid further delays", 1.0)
+        add_insight(f"Initiate {phase}: {task} in {city} immediately to avoid further delays.", 1.0)
     if expected_duration == 0 or actual_duration == 0:
-        add_insight("Provide accurate duration estimates for reliable predictions", 0.7)
+        add_insight(f"Provide accurate duration estimates for {phase}: {task} in {city} for reliable predictions.", 0.7)
+    if weather_score > 50 and phase == "Construction":
+        add_insight(f"Prepare contingency plans for {phase}: {task} in {city} 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}"]
+    return selected_insights or [f"No significant delay factors detected for {phase}: {task} in {city}."]
 
 def predict_delay(input_data: Dict) -> Dict:
     """
     Predict delay probability based on project task data.
-    Uses task duration, progress, workforce info, and weather condition.
+    Uses task duration, progress, workforce info, and weather impact.
     Insights are generated using detailed hardcoded rules.
     """
     logger.info("Starting delay prediction")
@@ -130,11 +153,17 @@ def predict_delay(input_data: Dict) -> Dict:
     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 %
+    
+    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_condition = input_data.get("weather_condition", "").lower()
+    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 = {
@@ -173,16 +202,9 @@ def predict_delay(input_data: Dict) -> Dict:
     elif shift_hours > 8:
         delay_risk -= min((shift_hours - 8) * 2, 10)
 
-    # 6. Weather condition effect
-    weather_risk_map = {
-        "severe storm": 20,
-        "heavy rain": 15,
-        "light rain": 10,
-        "cloudy": 5,
-        "partly cloudy": 2,
-        "sunny": 0
-    }
-    delay_risk += weather_risk_map.get(weather_condition, 0)
+    # 6. Weather impact effect
+    if weather_score > 50:
+        delay_risk += min(weather_score / 2, 20)
 
     # Ensure delay_risk is between 0 and 100
     delay_risk = max(0, min(delay_risk, 100))