Update app.py

app.py

@@ -2,252 +2,228 @@
 
 import gradio as gr
 import numpy as np
-from part1_data import TobaccoAnalyzer
-from part2_visualization import VisualizationHandler
-import ee
+from datetime import datetime, timedelta
+import folium
+from folium import plugins
+import requests
+from geopy.geocoders import Nominatim
+from geopy.exc import GeocoderTimedOut
+import pandas as pd
+from scipy import stats
 
-def analyze_location(location_name):
-    """Main analysis function with enhanced historical, forecast, and NDVI data"""
-    try:
-        # Initialize Earth Engine
+class TobaccoAnalyzer:
+    def __init__(self):
+        self.api_key = os.getenv('OPENWEATHER_API_KEY', 'default_key')
+        self.optimal_conditions = {
+            'temperature': {'min': 20, 'max': 30},
+            'humidity': {'min': 60, 'max': 80},
+            'rainfall': {'min': 500/365, 'max': 1200/365}
+        }
+        self.geolocator = Nominatim(user_agent="tobacco_analyzer")
+
+    def get_osm_data(self, lat, lon, radius=2000):
+        """Get land use data from OpenStreetMap"""
         try:
-            ee.Initialize()
+            # OSM Overpass API query for land use
+            overpass_url = "http://overpass-api.de/api/interpreter"
+            query = f"""
+            [out:json];
+            (
+              way["landuse"](around:{radius},{lat},{lon});
+              relation["landuse"](around:{radius},{lat},{lon});
+            );
+            out body;
+            >;
+            out skel qt;
+            """
+            response = requests.get(overpass_url, params={'data': query})
+            if response.status_code == 200:
+                return response.json()
+            return None
         except Exception as e:
-            print(f"Earth Engine initialization error: {e}")
-        
+            print(f"Error fetching OSM data: {e}")
+            return None
+
+def analyze_location(location_name):
+    """Main analysis function with enhanced historical and forecast data"""
+    try:
         analyzer = TobaccoAnalyzer()
         visualizer = VisualizationHandler(analyzer.optimal_conditions)
         
         # Get coordinates from location name
         location_data = analyzer.geocode_location(location_name)
         if not location_data:
-            return None, None, "Location not found. Please try a different location name.", None, None
+            return None, None, "Location not found. Please try a different location name.", None
         
         lat, lon = location_data['lat'], location_data['lon']
         
-        # Get enhanced weather data
+        # Get weather data
         df = analyzer.get_weather_data(lat, lon, historical_days=90, forecast_days=90)
-        if df.empty:
-            return None, None, "Unable to fetch weather data. Please try again.", None, None
+        if df is None or df.empty:
+            return None, None, "Unable to fetch weather data. Please try again.", None
         
-        # Get NDVI data
-        ndvi_data = analyzer.get_ndvi_data(lat, lon)
-        ndvi_score = analyzer.calculate_ndvi_score(ndvi_data) if ndvi_data else None
+        # Get land use data
+        osm_data = analyzer.get_osm_data(lat, lon)
         
-        # Calculate scores and trends as before
+        # Calculate scores
         historical = df[df['type'] == 'historical']
         forecast = df[df['type'].isin(['forecast_5day', 'forecast_extended'])]
         
-        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)
-        
-        trends = analyzer.analyze_trends(df)
+        # Safety checks for None values
+        if historical is None or historical.empty:
+            return None, None, "No historical data available.", None
+            
+        temp_mean = historical['temperature'].mean()
+        humidity_mean = historical['humidity'].mean()
+        rainfall_mean = historical['rainfall'].mean()
         
-        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
+        if any(x is None for x in [temp_mean, humidity_mean, rainfall_mean]):
+            return None, None, "Invalid weather data received.", None
+            
+        temp_score = np.clip((temp_mean - 15) / (30 - 15), 0, 1)
+        humidity_score = np.clip((humidity_mean - 50) / (80 - 50), 0, 1)
+        rainfall_score = np.clip(rainfall_mean / 5, 0, 1)
         
-        # Calculate combined score including NDVI
-        if ndvi_score is not None:
-            overall_score = np.average([temp_score, humidity_score, rainfall_score, ndvi_score], 
-                                     weights=[0.3, 0.2, 0.2, 0.3])
-        else:
-            overall_score = np.mean([temp_score, humidity_score, rainfall_score])
+        # Analyze trends with error handling
+        try:
+            trends = analyzer.analyze_trends(df)
+            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
+        except Exception as e:
+            print(f"Error in trend analysis: {e}")
+            trends = None
         
+        # Calculate overall score
+        overall_score = np.mean([temp_score, humidity_score, rainfall_score])
         overall_score = np.clip(overall_score, 0, 1)
         
-        # Create enhanced visualizations
+        # 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_data)
-        
-        # Generate NDVI analysis text
-        ndvi_analysis = ""
-        if ndvi_data and 'stats' in ndvi_data:
-            ndvi_stats = ndvi_data['stats']
-            mean_ndvi = ndvi_stats.get('NDVI_mean', 0)
-            ndvi_analysis = f"""
-            🌿 NDVI Analysis:
-            Mean NDVI: {mean_ndvi:.3f}
-            Vegetation Health: {get_ndvi_status(mean_ndvi)}
-            NDVI Score: {ndvi_score:.2f}
-            Contribution to Overall Score: 30%
-            """
-
-        # Generate recommendation and analysis text
-        recommendation = get_recommendation(overall_score)
         
+        # Create enhanced map with OSM data
+        m = folium.Map(location=[lat, lon], zoom_start=13)
+        
+        # Add weather data overlay
+        radius = 2000  # 2km radius
+        color = get_score_color(overall_score)
+        
+        folium.Circle(
+            radius=radius,
+            location=[lat, lon],
+            popup=f'Growing Suitability Score: {overall_score:.2f}',
+            color=color,
+            fill=True,
+            fillOpacity=0.4
+        ).add_to(m)
+        
+        # Add heatmap if we have enough data points
+        if not historical.empty and len(historical) > 0:
+            heat_data = [[row['temperature'], row['humidity'], row['rainfall']] 
+                        for _, row in historical.iterrows()]
+            plugins.HeatMap(heat_data).add_to(m)
+        
+        # Generate analysis text with safe string formatting
         analysis_text = f"""
         📍 Location Analysis:
-        Location: {location_data['address']}
+        Location: {location_data.get('address', 'Unknown')}
         Coordinates: {lat:.4f}°N, {lon:.4f}°E
         
         🌡️ Historical Weather Analysis (Past 90 Days):
-        Temperature: {historical['temperature'].mean():.1f}°C (±{historical['temperature'].std():.1f}°C)
-        Humidity: {historical['humidity'].mean():.1f}% (±{historical['humidity'].std():.1f}%)
-        Rainfall: {historical['rainfall'].mean():.1f}mm/day (±{historical['rainfall'].std():.1f}mm)
+        Temperature: {temp_mean:.1f}°C
+        Humidity: {humidity_mean:.1f}%
+        Rainfall: {rainfall_mean:.1f}mm/day
         
         📈 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
+        """
         
-        🔮 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)
+        if trends:
+            analysis_text += f"""
+            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
+            """
         
-        {ndvi_analysis}
+        if not forecast.empty:
+            analysis_text += f"""
+            🔮 Forecast Analysis (Next 90 Days):
+            Temperature: {forecast['temperature'].mean():.1f}°C
+            Humidity: {forecast['humidity'].mean():.1f}%
+            Rainfall: {forecast['rainfall'].mean():.1f}mm/day
+            """
         
-        📊 Condition Scores:
+        analysis_text += f"""
+        📊 Growing Condition Scores:
         Temperature Score: {temp_score:.2f}
         Humidity Score: {humidity_score:.2f}
         Rainfall Score: {rainfall_score:.2f}
-        NDVI Score: {ndvi_score:.2f if ndvi_score is not None else 'N/A'}
         Overall Score: {overall_score:.2f}
         
-        🎯 {recommendation}
-        
-        💰 Credit Risk Assessment:
-        Risk Level: {get_risk_level(overall_score)}
-        Recommended Actions: {get_risk_recommendations(overall_score)}
+        🎯 Recommendation: {get_recommendation(overall_score)}
         """
         
-        return time_series_plot, gauge_plot, analysis_text, location_map, gr.update(visible=False)
+        return time_series_plot, gauge_plot, analysis_text, m._repr_html_()
         
     except Exception as e:
         error_message = f"An error occurred: {str(e)}"
-        return None, None, error_message, None, gr.update(visible=True, value=error_message)
-
-def get_ndvi_status(ndvi):
-    """Get vegetation status based on NDVI value"""
-    if ndvi < 0:
-        return "Very Poor - Bare soil or water"
-    elif ndvi < 0.2:
-        return "Poor - Sparse or stressed vegetation"
-    elif ndvi < 0.4:
-        return "Moderate - Typical agricultural land"
-    elif ndvi < 0.6:
-        return "Good - Healthy vegetation"
-    else:
-        return "Excellent - Dense, very healthy vegetation"
-
-def get_recommendation(score):
-    """Get detailed recommendation based on score"""
-    if score >= 0.8:
-        return "Excellent conditions for tobacco growing! High probability of successful crop."
-    elif score >= 0.6:
-        return "Good conditions. Regular monitoring recommended. Consider crop insurance."
-    elif score >= 0.4:
-        return "Moderate conditions. Additional interventions may be needed. Insurance strongly recommended."
-    else:
-        return "Poor conditions. High risk for tobacco growing. Consider alternative crops or timing."
+        return None, None, error_message, None
 
-def get_risk_level(score):
-    """Determine credit risk level based on overall score"""
+def get_score_color(score):
+    """Get color based on score"""
     if score >= 0.8:
-        return "Low Risk"
+        return 'green'
     elif score >= 0.6:
-        return "Moderate Risk"
+        return 'yellow'
     elif score >= 0.4:
-        return "High Risk"
-    else:
-        return "Very High Risk"
+        return 'orange'
+    return 'red'
 
-def get_risk_recommendations(score):
-    """Get credit-related recommendations based on score"""
+def get_recommendation(score):
+    """Get recommendation based on score"""
     if score >= 0.8:
-        return "Standard loan terms, consider preferential rates"
+        return "✅ Excellent conditions for tobacco growing!"
     elif score >= 0.6:
-        return "Regular loan terms with mandatory crop insurance"
+        return "👍 Good conditions. Monitor weather patterns."
     elif score >= 0.4:
-        return "Higher interest rates, reduced loan amount, mandatory insurance"
-    else:
-        return "Consider alternative financing options or different crop selection"
+        return "⚠️ Marginal conditions. Consider interventions."
+    return "❌ Poor conditions. Not recommended for planting."
 
-# Create custom theme
-custom_theme = gr.themes.Monochrome(
-    primary_hue="blue",
-    secondary_hue="blue",
-    neutral_hue="gray",
-    radius_size=gr.themes.sizes.radius_sm,
-    font=[gr.themes.GoogleFont("Open Sans"), "ui-sans-serif", "system-ui", "sans-serif"],
-)
-
-# Create Gradio interface with enhanced layout
-with gr.Blocks(theme=custom_theme) as iface:
+# Create Gradio interface
+with gr.Blocks() as iface:
     gr.Markdown(
         """
-        # 🌱 Agricultural Credit Risk Assessment System
-        ## Integrating Weather, NDVI, and Credit Scoring for Tobacco Farming
-        """,
-        elem_classes="custom-markdown"
+        # 🌱 Tobacco Growth Prediction for Credit Scoring
+        """
     )
     
     with gr.Row():
-        with gr.Column(scale=4):
-            location_input = gr.Textbox(
-                label="Enter Location",
-                placeholder="e.g., Tabora, Tanzania",
-                lines=1
-            )
-        with gr.Column(scale=1):
-            analyze_button = gr.Button("🔍 Analyze", variant="primary")
+        location_input = gr.Textbox(
+            label="Enter Location",
+            placeholder="e.g., Tabora, Tanzania",
+            lines=1
+        )
+        analyze_button = gr.Button("📊 Analyze")
     
-    with gr.Tabs():
-        with gr.TabItem("📊 Analysis Dashboard"):
-            with gr.Row():
-                analysis_text = gr.Textbox(
-                    label="Comprehensive Analysis Results",
-                    lines=20,
-                    interactive=False
-                )
-            
-            with gr.Row():
-                weather_plot = gr.Plot(label="Weather Analysis")
-            
-            with gr.Row():
-                with gr.Column(scale=1):
-                    score_gauge = gr.Plot(label="Credit Risk Score")
-                with gr.Column(scale=1):
-                    location_map = gr.HTML(label="Location & NDVI Analysis")
-        
-        with gr.TabItem("ℹ️ Help & Information"):
-            gr.Markdown("""
-            ### How to Use This Tool
-            1. Enter a location name in Tanzania (preferably in Tabora region)
-            2. Click 'Analyze' to get comprehensive results
-            3. View weather patterns, NDVI analysis, and credit risk assessment
-            
-            ### Understanding the Results
-            - Weather Analysis: Historical and forecast data
-            - NDVI: Vegetation health indicator
-            - Credit Risk Score: Combined assessment of all factors
-            - Recommendations: Specific actions based on analysis
-            
-            ### Important Notes
-            - All scores are normalized to 0-1 scale
-            - NDVI analysis requires clear satellite imagery
-            - Weather forecasts are estimates
-            """)
+    with gr.Row():
+        analysis_text = gr.Textbox(
+            label="Analysis Results",
+            lines=15,
+            interactive=False
+        )
     
-    # Error message container
-    error_output = gr.Textbox(
-        label="Status",
-        visible=False,
-        interactive=False
-    )
+    with gr.Row():
+        weather_plot = gr.Plot(label="Weather Analysis")
     
-    analyze_button.click(
-        fn=analyze_location,
-        inputs=[location_input],
-        outputs=[weather_plot, score_gauge, analysis_text, location_map, error_output]
-    )
+    with gr.Row():
+        with gr.Column(scale=1):
+            score_gauge = gr.Plot(label="Growing Conditions Score")
+        with gr.Column(scale=1):
+            location_map = gr.HTML(label="Location Analysis")
     
-    # Example locations in Tanzania
-    gr.Examples(
+    # Set up the example handling
+    examples = gr.Examples(
         examples=[
             ["Tabora, Tanzania"],
             ["Urambo, Tabora, Tanzania"],
@@ -255,9 +231,17 @@ with gr.Blocks(theme=custom_theme) as iface:
             ["Nzega, Tabora, Tanzania"]
         ],
         inputs=location_input,
-        outputs=[weather_plot, score_gauge, analysis_text, location_map, error_output],
+        outputs=[weather_plot, score_gauge, analysis_text, location_map],
         fn=analyze_location,
         cache_examples=True,
+        preprocess=True
+    )
+    
+    # Handle button click
+    analyze_button.click(
+        fn=analyze_location,
+        inputs=[location_input],
+        outputs=[weather_plot, score_gauge, analysis_text, location_map]
     )
 
 # Launch the app