Update app.py

app.py

@@ -1,135 +1,197 @@
-# Add these imports to your existing imports if not already present
+# app.py
+
+import gradio as gr
+import numpy as np
+from datetime import datetime, timedelta
+import folium
 from folium import plugins
-import branca
+import requests
+from geopy.geocoders import Nominatim
+from geopy.exc import GeocoderTimedOut
+import pandas as pd
+from scipy import stats
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
 
-# Add this function to handle example processing
-def process_example(location_name):
-    """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
+class TobaccoAnalyzer:
+    def __init__(self):
+        self.api_key = 'your_api_key'  # Your existing API key setup
+        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'
+        }
 
-# 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_()
+    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
 
-# Update the Gradio interface section
-iface = gr.Blocks(theme=gr.themes.Base()) 
+    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}")
 
-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")
+        # 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)
+
+                # Generate extended forecast
+                last_date = max(d['date'] for d in forecast_data)
+                historical_df = pd.DataFrame(historical_data)
+                
+                if not historical_df.empty:
+                    for day in range(1, forecast_days - 5):
+                        date = last_date + timedelta(days=day)
+                        temp_trend = stats.linregress(range(len(historical_df)), historical_df['temperature'])[0]
+                        humidity_trend = stats.linregress(range(len(historical_df)), historical_df['humidity'])[0]
+                        rainfall_trend = stats.linregress(range(len(historical_df)), historical_df['rainfall'])[0]
+                        
+                        recent_temps = [d['temperature'] for d in forecast_data[-5:]]
+                        recent_humidity = [d['humidity'] for d in forecast_data[-5:]]
+                        recent_rainfall = [d['rainfall'] for d in forecast_data[-5:]]
+                        
+                        extended_forecast = {
+                            'date': date,
+                            'temperature': np.mean(recent_temps) + temp_trend * day,
+                            'humidity': np.mean(recent_humidity) + humidity_trend * day,
+                            'rainfall': np.mean(recent_rainfall) + rainfall_trend * day,
+                            'type': 'forecast_extended',
+                            'description': 'Extended Forecast'
+                        }
+                        forecast_data.append(extended_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)
             
-            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")
+            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()
         
-        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
+        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]
+                    }
+                }
+            }
             
-            ### 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]
-    )
+            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
+
+class VisualizationHandler:
+    def __init__(self, optimal_conditions):
+        self.optimal_conditions = optimal_conditions
+
+    def create_interactive_plots(self, df):
+        """Create enhanced interactive Plotly visualizations"""
+        fig = make_subplots(
+            rows=3, cols=1,
+            subplot_titles=(
+                '<b>Temperature (°C)</b>',
+                '<b>Humidity (%)</b>',
+                '<b>Rainfall (mm/day)</b>'
+            ),
+            vertical_spacing=0.12,
+            row_heights=[0.33, 0.33, 0.33]
+        )