Update app.py

app.py

@@ -1,242 +1,135 @@
-import os
-import gradio as gr
-import numpy as np
-from datetime import datetime, timedelta
-import folium
+# Add these imports to your existing imports if not already present
 from folium import plugins
-import requests
-from geopy.geocoders import Nominatim
-from geopy.exc import GeocoderTimedOut
-import pandas as pd
-from scipy import stats
-
-# Load environment variables
-load_dotenv()
-
-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")
-        self.seasons = {
-            1: 'Winter', 2: 'Winter', 3: 'Spring',
-            4: 'Spring', 5: 'Spring', 6: 'Summer',
-            7: 'Summer', 8: 'Summer', 9: 'Fall',
-            10: 'Fall', 11: 'Fall', 12: 'Winter'
-        }
-
-    def geocode_location(self, location_name):
-        """Convert location name to coordinates"""
-        try:
-            location = self.geolocator.geocode(location_name)
-            if location:
-                return {
-                    'lat': location.latitude,
-                    'lon': location.longitude,
-                    'address': location.address
-                }
-            return None
-        except GeocoderTimedOut:
-            return None
-
-    def get_weather_data(self, lat, lon, historical_days=90, forecast_days=90):
-        """Get historical and forecast weather data"""
-        historical_data = []
-        
-        # Get historical data
-        for day in range(historical_days):
-            date = datetime.now() - timedelta(days=day)
-            url = f"https://api.openweathermap.org/data/2.5/weather?lat={lat}&lon={lon}&appid={self.api_key}&units=metric&dt={int(date.timestamp())}"
-            try:
-                response = requests.get(url)
-                if response.status_code == 200:
-                    data = response.json()
-                    weather_data = {
-                        'date': date,
-                        'temperature': data['main']['temp'],
-                        'humidity': data['main']['humidity'],
-                        'rainfall': data.get('rain', {}).get('1h', 0) * 24,
-                        'type': 'historical',
-                        'description': data['weather'][0]['description']
-                    }
-                    historical_data.append(weather_data)
-            except Exception as e:
-                print(f"Error fetching historical data: {e}")
-
-        # Get forecast data
-        forecast_data = []
-        try:
-            forecast_url = f"https://api.openweathermap.org/data/2.5/forecast?lat={lat}&lon={lon}&appid={self.api_key}&units=metric"
-            response = requests.get(forecast_url)
-            if response.status_code == 200:
-                data = response.json()
-                for item in data['list']:
-                    forecast = {
-                        'date': datetime.fromtimestamp(item['dt']),
-                        'temperature': item['main']['temp'],
-                        'humidity': item['main']['humidity'],
-                        'rainfall': item.get('rain', {}).get('3h', 0) * 8,
-                        'type': 'forecast_5day',
-                        'description': item['weather'][0]['description']
-                    }
-                    forecast_data.append(forecast)
-
-        except Exception as e:
-            print(f"Error fetching forecast data: {e}")
-
-        if not historical_data and not forecast_data:
-            return None
-
-        # Combine and process data
-        all_data = pd.DataFrame(historical_data + forecast_data)
-        if not all_data.empty:
-            all_data = all_data.sort_values('date')
-            all_data['month'] = all_data['date'].dt.month
-            all_data['season'] = all_data['month'].map(self.seasons)
-            
-            # Calculate rolling averages
-            all_data['temp_7day_avg'] = all_data['temperature'].rolling(window=7, min_periods=1).mean()
-            all_data['humidity_7day_avg'] = all_data['humidity'].rolling(window=7, min_periods=1).mean()
-            all_data['rainfall_7day_avg'] = all_data['rainfall'].rolling(window=7, min_periods=1).mean()
-            
-        return all_data
-
-    def analyze_trends(self, df):
-        """Analyze weather trends and patterns"""
-        try:
-            historical = df[df['type'] == 'historical']
-            forecast = df[df['type'].isin(['forecast_5day', 'forecast_extended'])]
-            
-            if historical.empty:
-                return None
-            
-            analysis = {
-                'historical': {
-                    'temperature': {
-                        'mean': historical['temperature'].mean(),
-                        'std': historical['temperature'].std(),
-                        'trend': stats.linregress(range(len(historical)), historical['temperature'])[0]
-                    },
-                    'humidity': {
-                        'mean': historical['humidity'].mean(),
-                        'std': historical['humidity'].std(),
-                        'trend': stats.linregress(range(len(historical)), historical['humidity'])[0]
-                    },
-                    'rainfall': {
-                        'mean': historical['rainfall'].mean(),
-                        'std': historical['rainfall'].std(),
-                        'trend': stats.linregress(range(len(historical)), historical['rainfall'])[0]
-                    }
-                }
-            }
-            
-            if not forecast.empty:
-                analysis['forecast'] = {
-                    'temperature': {
-                        'mean': forecast['temperature'].mean(),
-                        'std': forecast['temperature'].std(),
-                    },
-                    'humidity': {
-                        'mean': forecast['humidity'].mean(),
-                        'std': forecast['humidity'].std(),
-                    },
-                    'rainfall': {
-                        'mean': forecast['rainfall'].mean(),
-                        'std': forecast['rainfall'].std(),
-                    }
-                }
-            
-            return analysis
-        except Exception as e:
-            print(f"Error in trend analysis: {e}")
-            return None
+import branca
 
+# Add this function to handle example processing
 def process_example(location_name):
-    """Process example inputs"""
+    """Process example inputs with proper error handling"""
     try:
         return analyze_location(location_name)
     except Exception as e:
         print(f"Error processing example: {e}")
         return None, None, f"Error processing example: {str(e)}", None
 
-def analyze_location(location_name):
-    """Main analysis function"""
-    try:
-        analyzer = TobaccoAnalyzer()
-        
-        # Get coordinates
-        location_data = analyzer.geocode_location(location_name)
-        if not location_data:
-            return None, None, "Location not found. Please try a different location name.", None
-        
-        lat, lon = location_data['lat'], location_data['lon']
-        
-        # Get weather data
-        df = analyzer.get_weather_data(lat, lon)
-        if df is None or df.empty:
-            return None, None, "Unable to fetch weather data. Please try again.", None
-        
-        # Calculate scores
-        historical = df[df['type'] == 'historical']
-        
-        temp_mean = historical['temperature'].mean()
-        humidity_mean = historical['humidity'].mean()
-        rainfall_mean = historical['rainfall'].mean()
-        
-        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)
-        
-        # Get trends
-        trends = analyzer.analyze_trends(df)
-        
-        # Calculate overall score
-        overall_score = np.mean([temp_score, humidity_score, rainfall_score])
-        overall_score = np.clip(overall_score, 0, 1)
-        
-        # Create visualizations
-        weather_plot = create_weather_plot(df, analyzer.optimal_conditions)
-        gauge_plot = create_gauge_chart(overall_score)
-        map_html = create_map(lat, lon, overall_score)
-        
-        # Create analysis text
-        analysis_text = create_analysis_text(location_data, historical, trends, overall_score,
-                                          temp_score, humidity_score, rainfall_score)
-        
-        return weather_plot, gauge_plot, analysis_text, map_html
-        
-    except Exception as e:
-        error_message = f"An error occurred: {str(e)}"
-        print(f"Error details: {e}")
-        return None, None, error_message, None
+# Update your create_map function inside VisualizationHandler class
+def create_map(self, lat, lon, score):
+    """Create an enhanced interactive map with weather and terrain analysis"""
+    m = folium.Map(location=[lat, lon], zoom_start=13)
+    
+    # Add main analysis circle
+    color = self.get_color_for_score(score)
+    folium.Circle(
+        radius=2000,  # 2km radius
+        location=[lat, lon],
+        popup=f'Growing Suitability Score: {score:.2f}',
+        color=color,
+        fill=True,
+        fillOpacity=0.4
+    ).add_to(m)
+    
+    # Add terrain analysis circles
+    for radius in [1000, 1500]:
+        folium.Circle(
+            radius=radius,
+            location=[lat, lon],
+            color=color,
+            fill=False,
+            weight=1
+        ).add_to(m)
+    
+    # Add custom legend
+    legend_html = """
+    <div style="position: fixed; bottom: 50px; left: 50px; z-index: 1000; background-color: white;
+                padding: 10px; border-radius: 5px; border: 2px solid grey;">
+        <h4>Suitability Score</h4>
+        <div><i style="background: green"></i> High (>0.8)</div>
+        <div><i style="background: yellow"></i> Good (>0.6)</div>
+        <div><i style="background: orange"></i> Moderate (>0.4)</div>
+        <div><i style="background: red"></i> Low (<0.4)</div>
+    </div>
+    """
+    m.get_root().html.add_child(folium.Element(legend_html))
+    
+    # Add measurement tool
+    plugins.MeasureControl(position='topright').add_to(m)
+    
+    # Add fullscreen option
+    plugins.Fullscreen().add_to(m)
+    
+    # Add mini map
+    minimap = plugins.MiniMap()
+    m.add_child(minimap)
+    
+    return m._repr_html_()
 
-# Create Gradio interface
-demo = gr.Interface(
-    fn=analyze_location,
-    inputs=[
-        gr.Textbox(label="Enter Location", placeholder="e.g., Tabora, Tanzania")
-    ],
-    outputs=[
-        gr.Plot(label="Weather Analysis"),
-        gr.Plot(label="Growing Conditions Score"),
-        gr.Textbox(label="Analysis Results", lines=15),
-        gr.HTML(label="Location Analysis")
-    ],
-    title="🌱 Tobacco Growth Prediction for Credit Scoring",
-    description="Enter a location to analyze growing conditions and credit risk.",
-    examples=[
-        ["Tabora, Tanzania"],
-        ["Urambo, Tabora, Tanzania"],
-        ["Sikonge, Tabora, Tanzania"],
-        ["Nzega, Tabora, Tanzania"]
-    ],
-    cache_examples=True
-)
+# Update the Gradio interface section
+iface = gr.Blocks(theme=gr.themes.Base()) 
 
-# Launch the app
-if __name__ == "__main__":
-    demo.launch()
+with iface:
+    gr.Markdown(
+        """
+        # 🌱 Tobacco Growth Prediction for Credit Scoring
+        Enter a location in Tanzania to analyze growing conditions and assess credit risk.
+        """
+    )
+    
+    with gr.Row():
+        location_input = gr.Textbox(
+            label="Enter Location",
+            placeholder="e.g., Tabora, Tanzania",
+            lines=1
+        )
+        analyze_button = gr.Button("📊 Analyze", variant="primary")
+    
+    with gr.Tabs():
+        with gr.TabItem("📊 Analysis Results"):
+            with gr.Row():
+                analysis_text = gr.Textbox(
+                    label="Comprehensive Analysis",
+                    lines=15,
+                    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="Suitability Score")
+                with gr.Column(scale=1):
+                    location_map = gr.HTML(label="Location Analysis")
+        
+        with gr.TabItem("ℹ️ Help"):
+            gr.Markdown("""
+            ### How to Use:
+            1. Enter a location name in Tanzania (preferably in Tabora region)
+            2. Click 'Analyze' to get comprehensive results
+            3. View the analysis in different tabs
+            
+            ### Understanding Results:
+            - Weather Analysis: Shows historical and forecast patterns
+            - Suitability Score: Overall assessment of growing conditions
+            - Location Analysis: Interactive map with terrain analysis
+            """)
+    
+    # Set up examples with proper handling
+    gr.Examples(
+        examples=[
+            ["Tabora, Tanzania"],
+            ["Urambo, Tabora, Tanzania"],
+            ["Sikonge, Tabora, Tanzania"],
+            ["Nzega, Tabora, Tanzania"]
+        ],
+        inputs=location_input,
+        outputs=[weather_plot, score_gauge, analysis_text, location_map],
+        fn=process_example,
+        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]
+    )