Update app.py

app.py

@@ -1,5 +1,3 @@
-# app.py
-
 import gradio as gr
 import numpy as np
 from datetime import datetime, timedelta
@@ -9,16 +7,6 @@ import branca.colormap as cm
 from part1_data import TobaccoAnalyzer
 from part2_visualization import VisualizationHandler
 
-def calculate_ndvi(lat, lon, radius=2000):
-    """Calculate synthetic NDVI based on weather and location data"""
-    # Simulate NDVI based on weather conditions and season
-    month = datetime.now().month
-    # Spring/Summer months typically have higher NDVI
-    season_factor = 1.0 if month in [3,4,5,6,7,8] else 0.7
-    
-    base_ndvi = 0.4  # Base NDVI value for agricultural areas
-    return base_ndvi * season_factor
-
 def analyze_location(location_name):
     """Main analysis function with enhanced historical and forecast data"""
     try:
@@ -34,84 +22,97 @@ def analyze_location(location_name):
         
         # Get enhanced weather data
         df = analyzer.get_weather_data(lat, lon, historical_days=90, forecast_days=90)
-        if df.empty:
+        if df is None or df.empty:
             return None, None, "Unable to fetch weather data. Please try again.", None
         
-        # Calculate NDVI score
-        ndvi_value = calculate_ndvi(lat, lon)
-        ndvi_score = np.clip((ndvi_value + 1) / 2, 0, 1)  # Convert -1:1 to 0:1 scale
-        
-        # Calculate weather scores
+        # Calculate scores
         historical = df[df['type'] == 'historical']
-        forecast = df[df['type'].isin(['forecast_5day', 'forecast_extended'])]
+        forecast = df[df['type'] == 'forecast']
         
-        temp_score = np.clip((df['temperature'].mean() - 15) / (30 - 15), 0, 1)
-        humidity_score = np.clip((df['humidity'].mean() - 50) / (80 - 50), 0, 1)
-        rainfall_score = np.clip(df['rainfall'].mean() / 5, 0, 1)
+        # Calculate base scores
+        temp_score = np.clip((historical['temperature'].mean() - 15) / (30 - 15), 0, 1)
+        humidity_score = np.clip((historical['humidity'].mean() - 50) / (80 - 50), 0, 1)
+        rainfall_score = np.clip(historical['rainfall'].mean() / 5, 0, 1)
         
-        # Analyze trends
+        # Get trends and NDVI
         trends = analyzer.analyze_trends(df)
+        ndvi_score = historical['estimated_ndvi'].mean()
         
-        # Adjust scores based on trends
-        trend_factor = 0.1
-        temp_score += trends['historical']['temperature']['trend'] * trend_factor
-        humidity_score += trends['historical']['humidity']['trend'] * trend_factor
-        rainfall_score += trends['historical']['rainfall']['trend'] * trend_factor
+        # Calculate combined score
+        weights = {
+            'temperature': 0.3,
+            'humidity': 0.2,
+            'rainfall': 0.2,
+            'ndvi': 0.3
+        }
         
-        # Calculate combined score including NDVI
-        scores = [temp_score, humidity_score, rainfall_score, ndvi_score]
-        weights = [0.3, 0.2, 0.2, 0.3]  # NDVI has equal weight to temperature
-        overall_score = np.average(scores, weights=weights)
-        overall_score = np.clip(overall_score, 0, 1)
+        overall_score = (
+            temp_score * weights['temperature'] +
+            humidity_score * weights['humidity'] +
+            rainfall_score * weights['rainfall'] +
+            ndvi_score * weights['ndvi']
+        )
         
         # Create visualizations
         time_series_plot = visualizer.create_interactive_plots(df)
         gauge_plot = visualizer.create_gauge_chart(overall_score)
-        location_map = visualizer.create_enhanced_map(lat, lon, overall_score, ndvi_value)
+        location_map = visualizer.create_enhanced_map(lat, lon, overall_score, ndvi_score)
         
-        # Generate vegetation status
-        ndvi_status = get_vegetation_status(ndvi_value)
+        # Generate risk assessment
+        risk_level = get_risk_level(overall_score)
+        risk_details = get_risk_details(overall_score, ndvi_score)
         
-        # Generate analysis text with NDVI information
+        # Generate comprehensive analysis text
         analysis_text = f"""
         📍 Location Analysis:
         Location: {location_data['address']}
         Coordinates: {lat:.4f}°N, {lon:.4f}°E
+        Region: {location_data['region'] if location_data['region'] else 'Unknown'}
         
         🌡️ Historical Weather Analysis (Past 90 Days):
         Temperature: {historical['temperature'].mean():.1f}°C (±{historical['temperature'].std():.1f}°C)
+        Daily Range: {historical['temp_range'].mean():.1f}°C
         Humidity: {historical['humidity'].mean():.1f}% (±{historical['humidity'].std():.1f}%)
         Rainfall: {historical['rainfall'].mean():.1f}mm/day (±{historical['rainfall'].std():.1f}mm)
         
-        🌿 Vegetation Analysis (NDVI):
-        NDVI Value: {ndvi_value:.2f}
-        Vegetation Status: {ndvi_status}
-        Vegetation Score: {ndvi_score:.2f}
+        🌿 Vegetation Analysis:
+        NDVI Score: {ndvi_score:.2f}
+        Vegetation Status: {get_vegetation_status(ndvi_score)}
+        Seasonal Impact: {get_seasonal_impact(df['season'].iloc[-1])}
         
         📈 Weather Trends:
-        Temperature Trend: {trends['historical']['temperature']['trend']:.3f}°C/day
-        Humidity Trend: {trends['historical']['humidity']['trend']:.3f}%/day
-        Rainfall Trend: {trends['historical']['rainfall']['trend']:.3f}mm/day
+        Temperature: {trends['historical']['temperature']['trend']:.3f}°C/day
+        Humidity: {trends['historical']['humidity']['trend']:.3f}%/day
+        Rainfall: {trends['historical']['rainfall']['trend']:.3f}mm/day
+        Vegetation: {trends['historical']['ndvi']['trend']:.3f} NDVI/day
         
         🔮 Forecast Analysis (Next 90 Days):
         Temperature: {forecast['temperature'].mean():.1f}°C (±{forecast['temperature'].std():.1f}°C)
         Humidity: {forecast['humidity'].mean():.1f}% (±{forecast['humidity'].std():.1f}%)
         Rainfall: {forecast['rainfall'].mean():.1f}mm/day (±{forecast['rainfall'].std():.1f}mm)
+        Expected NDVI: {forecast['estimated_ndvi'].mean():.2f}
         
         📊 Growing Condition Scores:
         Temperature Score: {temp_score:.2f}
         Humidity Score: {humidity_score:.2f}
         Rainfall Score: {rainfall_score:.2f}
-        NDVI Score: {ndvi_score:.2f}
+        Vegetation Score: {ndvi_score:.2f}
         Overall Score: {overall_score:.2f}
         
-        🎯 Recommendation: {get_recommendation(overall_score, ndvi_score)}
+        💰 Credit Risk Assessment:
+        Risk Level: {risk_level}
+        {risk_details}
+        
+        🎯 Recommendations:
+        {get_recommendations(overall_score, ndvi_score)}
+        
+        ⚠️ Risk Factors:
+        {get_risk_factors(df, trends)}
         
         📝 Additional Notes:
-        • Temperature is {'optimal' if temp_score > 0.8 else 'suboptimal'}
-        • Humidity levels are {'optimal' if humidity_score > 0.8 else 'suboptimal'}
-        • Rainfall is {'optimal' if rainfall_score > 0.8 else 'suboptimal'}
-        • Vegetation health is {ndvi_status.lower()}
+        • Growing Season: {is_growing_season(df['season'].iloc[-1])}
+        • Weather Stability: {get_weather_stability(df)}
+        • Long-term Outlook: {get_long_term_outlook(trends)}
         """
         
         return time_series_plot, gauge_plot, analysis_text, location_map
@@ -120,8 +121,25 @@ def analyze_location(location_name):
         error_message = f"An error occurred: {str(e)}"
         return None, None, error_message, None
 
+def get_risk_level(score):
+    if score >= 0.8:
+        return "Low Risk 🟢"
+    elif score >= 0.6:
+        return "Moderate Risk 🟡"
+    elif score >= 0.4:
+        return "High Risk 🟠"
+    return "Very High Risk 🔴"
+
+def get_risk_details(score, ndvi):
+    if score >= 0.8 and ndvi >= 0.6:
+        return "Excellent conditions for credit. Consider preferential rates."
+    elif score >= 0.6:
+        return "Good conditions. Standard credit terms with basic risk mitigation."
+    elif score >= 0.4:
+        return "Marginal conditions. Higher rates and strong risk mitigation required."
+    return "Poor conditions. Credit not recommended without substantial collateral."
+
 def get_vegetation_status(ndvi):
-    """Get vegetation status based on NDVI value"""
     if ndvi < 0:
         return "Very Poor - Bare soil or water"
     elif ndvi < 0.2:
@@ -130,26 +148,90 @@ def get_vegetation_status(ndvi):
         return "Moderate - Typical agricultural land"
     elif ndvi < 0.6:
         return "Good - Healthy vegetation"
-    else:
-        return "Excellent - Dense, very healthy vegetation"
+    return "Excellent - Dense, very healthy vegetation"
 
-def get_recommendation(overall_score, ndvi_score):
-    """Get detailed recommendation based on scores"""
-    if overall_score >= 0.8 and ndvi_score >= 0.6:
-        return "✅ Excellent conditions for tobacco growing! High probability of successful crop."
-    elif overall_score >= 0.6 and ndvi_score >= 0.4:
-        return "👍 Good conditions. Regular monitoring recommended. Consider crop insurance."
-    elif overall_score >= 0.4:
-        return "⚠️ Marginal conditions. Additional interventions needed. Insurance strongly recommended."
-    else:
-        return "❌ Poor conditions. High risk for tobacco growing. Consider alternative timing or location."
+def get_seasonal_impact(season):
+    seasons = {
+        'Main': "Prime growing season - Optimal conditions expected",
+        'Early': "Early growing season - Good potential with monitoring",
+        'Late': "Late growing season - Moderate risk",
+        'Dry': "Dry season - Higher risk period"
+    }
+    return seasons.get(season, "Unknown season impact")
+
+def is_growing_season(season):
+    return "Currently in growing season" if season in ['Main', 'Early'] else "Outside main growing season"
+
+def get_weather_stability(df):
+    std_temp = df['temperature'].std()
+    if std_temp < 2:
+        return "Very stable weather patterns"
+    elif std_temp < 4:
+        return "Moderately stable weather"
+    return "Unstable weather patterns - higher risk"
+
+def get_long_term_outlook(trends):
+    temp_trend = trends['historical']['temperature']['trend']
+    rain_trend = trends['historical']['rainfall']['trend']
+    
+    if temp_trend > 0 and rain_trend > 0:
+        return "Improving conditions"
+    elif temp_trend < 0 and rain_trend < 0:
+        return "Deteriorating conditions"
+    return "Stable conditions"
+
+def get_risk_factors(df, trends):
+    risk_factors = []
+    
+    # Temperature risks
+    if df['temp_range'].mean() > 15:
+        risk_factors.append("• High daily temperature variations")
+    
+    # Rainfall risks
+    if df['rainfall'].std() > df['rainfall'].mean():
+        risk_factors.append("• Inconsistent rainfall patterns")
+    
+    # Trend risks
+    if trends['historical']['temperature']['trend'] < 0:
+        risk_factors.append("• Declining temperature trend")
+    
+    return "\n".join(risk_factors) if risk_factors else "No major risk factors identified"
+
+def get_recommendations(score, ndvi):
+    if score >= 0.8 and ndvi >= 0.6:
+        return """
+        • Proceed with standard credit terms
+        • Consider preferential rates
+        • Regular monitoring recommended
+        """
+    elif score >= 0.6:
+        return """
+        • Proceed with caution
+        • Implement basic risk mitigation
+        • More frequent monitoring required
+        • Consider crop insurance
+        """
+    elif score >= 0.4:
+        return """
+        • Higher interest rates recommended
+        • Strong risk mitigation required
+        • Weekly monitoring needed
+        • Mandatory crop insurance
+        • Consider alternative crops
+        """
+    return """
+    • Credit not recommended
+    • Consider alternative location
+    • Extensive risk mitigation needed
+    • Alternative farming activities suggested
+    """
 
 # Create Gradio interface
 with gr.Blocks(theme=gr.themes.Base()) as iface:
     gr.Markdown(
         """
         # 🌱 Agricultural Credit Risk Assessment System
-        ## Weather, Vegetation, and Credit Scoring for Tobacco Farming
+        ## Integrated Weather, Vegetation, and Credit Scoring for Tobacco Farming
         """
     )
     
@@ -166,12 +248,12 @@ with gr.Blocks(theme=gr.themes.Base()) as iface:
             with gr.Row():
                 analysis_text = gr.Textbox(
                     label="Comprehensive Analysis",
-                    lines=20,
+                    lines=25,
                     interactive=False
                 )
             
             with gr.Row():
-                weather_plot = gr.Plot(label="Weather Analysis")
+                weather_plot = gr.Plot(label="Weather and Vegetation Analysis")
             
             with gr.Row():
                 with gr.Column(scale=1):
@@ -182,16 +264,16 @@ with gr.Blocks(theme=gr.themes.Base()) as iface:
         with gr.TabItem("ℹ️ Help"):
             gr.Markdown("""
             ### Understanding the Analysis:
-            - Weather Analysis: Historical and forecast patterns
-            - Vegetation Health (NDVI): Current vegetation status
-            - Credit Risk Score: Combined assessment of all factors
-            - Location Analysis: Interactive map with vegetation overlay
+            - Weather Data: Historical and forecast patterns
+            - Vegetation Health: NDVI analysis
+            - Credit Risk: Comprehensive scoring
+            - Location Analysis: Interactive mapping
             
             ### Score Interpretation:
-            - 0.8-1.0: Excellent conditions (Low risk)
-            - 0.6-0.8: Good conditions (Moderate risk)
-            - 0.4-0.6: Fair conditions (High risk)
-            - 0.0-0.4: Poor conditions (Very high risk)
+            - 0.8-1.0: Low Risk (Excellent conditions)
+            - 0.6-0.8: Moderate Risk (Good conditions)
+            - 0.4-0.6: High Risk (Marginal conditions)
+            - 0.0-0.4: Very High Risk (Poor conditions)
             """)
     
     # Set up examples