Update part1_data.py

part1_data.py

@@ -1,3 +1,6 @@
+```python
+# part1_data.py
+
 import os
 import numpy as np
 import pandas as pd
@@ -85,72 +88,20 @@ class TobaccoAnalyzer:
             response = requests.get(forecast_url)
             if response.status_code == 200:
                 data = response.json()
-                daily_forecasts = {}
-                
                 for item in data['list']:
                     date = datetime.fromtimestamp(item['dt'])
-                    day_key = date.date()
-                    
-                    if day_key not in daily_forecasts:
-                        daily_forecasts[day_key] = {
-                            'temps': [],
-                            'humidity': [],
-                            'rainfall': 0,
-                            'descriptions': [],
-                            'temp_mins': [],
-                            'temp_maxs': []
-                        }
-                    
-                    daily_forecasts[day_key]['temps'].append(float(item['main']['temp']))
-                    daily_forecasts[day_key]['humidity'].append(float(item['main']['humidity']))
-                    daily_forecasts[day_key]['rainfall'] += float(item.get('rain', {}).get('3h', 0))
-                    daily_forecasts[day_key]['descriptions'].append(item['weather'][0]['description'])
-                    daily_forecasts[day_key]['temp_mins'].append(float(item['main']['temp_min']))
-                    daily_forecasts[day_key]['temp_maxs'].append(float(item['main']['temp_max']))
-
-                # Create daily forecast entries
-                for day_key, day_data in daily_forecasts.items():
                     forecast = {
-                        'date': datetime.combine(day_key, datetime.min.time()),
-                        'temperature': np.mean(day_data['temps']),
-                        'temp_min': min(day_data['temp_mins']),
-                        'temp_max': max(day_data['temp_maxs']),
-                        'humidity': np.mean(day_data['humidity']),
-                        'rainfall': day_data['rainfall'],
+                        'date': date,
+                        'temperature': float(item['main']['temp']),
+                        'humidity': float(item['main']['humidity']),
+                        'rainfall': float(item.get('rain', {}).get('3h', 0)) * 8,
                         'type': 'forecast',
-                        'description': max(day_data['descriptions'], key=day_data['descriptions'].count)
+                        'description': item['weather'][0]['description'],
+                        'temp_min': float(item['main']['temp_min']),
+                        'temp_max': float(item['main']['temp_max'])
                     }
                     forecast_data.append(forecast)
 
-                # Generate extended forecast using trends
-                if forecast_data:
-                    last_date = max(d['date'] for d in forecast_data)
-                    temp_trend = 0
-                    humidity_trend = 0
-                    rainfall_trend = 0
-
-                    if len(historical_data) > 1:
-                        historical_df = pd.DataFrame(historical_data)
-                        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]
-
-                    for day in range(1, forecast_days - len(forecast_data)):
-                        base_forecast = forecast_data[-1]
-                        date = last_date + timedelta(days=day)
-                        
-                        extended_forecast = {
-                            'date': date,
-                            'temperature': base_forecast['temperature'] + temp_trend * day,
-                            'temp_min': base_forecast['temp_min'] + temp_trend * day,
-                            'temp_max': base_forecast['temp_max'] + temp_trend * day,
-                            'humidity': base_forecast['humidity'] + humidity_trend * day,
-                            'rainfall': max(0, base_forecast['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}")
 
@@ -158,27 +109,22 @@ class TobaccoAnalyzer:
         all_data = pd.DataFrame(historical_data + forecast_data)
         
         if not all_data.empty:
-            # Ensure numeric types
-            numeric_columns = ['temperature', 'humidity', 'rainfall', 'temp_min', 'temp_max']
-            for col in numeric_columns:
-                all_data[col] = pd.to_numeric(all_data[col], errors='coerce')
-
             # Sort by date
             all_data = all_data.sort_values('date')
             
-            # Calculate temperature range
-            all_data['temp_range'] = all_data['temp_max'] - all_data['temp_min']
-            
             # Add analysis columns
             all_data['month'] = all_data['date'].dt.month
             all_data['season'] = all_data['month'].map(self.tanzania_seasons)
             
+            # Calculate temperature range
+            all_data['temp_range'] = all_data['temp_max'] - all_data['temp_min']
+            
             # 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()
             
-            # Calculate daily suitability and NDVI
+            # Calculate suitability and NDVI
             all_data['daily_suitability'] = self.calculate_daily_suitability(all_data)
             all_data['estimated_ndvi'] = self.estimate_ndvi(all_data)
 
@@ -186,6 +132,79 @@ class TobaccoAnalyzer:
 
         return pd.DataFrame()
 
+    def analyze_trends(self, df):
+        """Analyze weather trends and patterns"""
+        try:
+            historical = df[df['type'] == 'historical']
+            forecast = df[df['type'].isin(['forecast', 'forecast_extended'])]
+            
+            if len(historical) < 2:
+                return None
+            
+            # Create time index for trend calculation
+            historical['days'] = (historical['date'] - historical['date'].min()).dt.total_seconds() / (24*60*60)
+            
+            # Calculate trends
+            temp_trend = stats.linregress(historical['days'], historical['temperature'])
+            humidity_trend = stats.linregress(historical['days'], historical['humidity'])
+            rainfall_trend = stats.linregress(historical['days'], historical['rainfall'])
+            ndvi_trend = stats.linregress(historical['days'], historical['estimated_ndvi'])
+            
+            analysis = {
+                'historical': {
+                    'temperature': {
+                        'mean': historical['temperature'].mean(),
+                        'std': historical['temperature'].std(),
+                        'trend': temp_trend.slope,
+                        'trend_r2': temp_trend.rvalue**2
+                    },
+                    'humidity': {
+                        'mean': historical['humidity'].mean(),
+                        'std': historical['humidity'].std(),
+                        'trend': humidity_trend.slope,
+                        'trend_r2': humidity_trend.rvalue**2
+                    },
+                    'rainfall': {
+                        'mean': historical['rainfall'].mean(),
+                        'std': historical['rainfall'].std(),
+                        'trend': rainfall_trend.slope,
+                        'trend_r2': rainfall_trend.rvalue**2
+                    },
+                    'ndvi': {
+                        'mean': historical['estimated_ndvi'].mean(),
+                        'std': historical['estimated_ndvi'].std(),
+                        'trend': ndvi_trend.slope,
+                        'trend_r2': ndvi_trend.rvalue**2
+                    }
+                }
+            }
+            
+            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()
+                    },
+                    'ndvi': {
+                        'mean': forecast['estimated_ndvi'].mean(),
+                        'std': forecast['estimated_ndvi'].std()
+                    }
+                }
+            
+            return analysis
+            
+        except Exception as e:
+            print(f"Error in trend analysis: {e}")
+            return None
+
     def calculate_daily_suitability(self, df):
         """Calculate daily growing suitability"""
         try:
@@ -249,83 +268,4 @@ class TobaccoAnalyzer:
         except Exception as e:
             print(f"Error estimating NDVI: {e}")
             return pd.Series(0, index=weather_data.index)
-
-def analyze_trends(self, df):
-    """Analyze weather trends and patterns with improved calculations"""
-    try:
-        historical = df[df['type'] == 'historical']
-        forecast = df[df['type'].isin(['forecast', 'forecast_extended'])]
-        
-        if len(historical) < 2:  # Need at least 2 points for trend
-            return None
-        
-        # Create time index for proper trend calculation
-        historical['days'] = (historical['date'] - historical['date'].min()).dt.total_seconds() / (24*60*60)
-        
-        # Calculate trends using proper time series analysis
-        temp_trend = stats.linregress(historical['days'], historical['temperature'])
-        humidity_trend = stats.linregress(historical['days'], historical['humidity'])
-        rainfall_trend = stats.linregress(historical['days'], historical['rainfall'])
-        ndvi_trend = stats.linregress(historical['days'], historical['estimated_ndvi'])
-        
-        analysis = {
-            'historical': {
-                'temperature': {
-                    'mean': historical['temperature'].mean(),
-                    'std': historical['temperature'].std(),
-                    'trend': temp_trend.slope,  # Change per day
-                    'trend_r2': temp_trend.rvalue**2,
-                    'recent_change': historical['temperature'].iloc[-1] - historical['temperature'].iloc[0]
-                },
-                'humidity': {
-                    'mean': historical['humidity'].mean(),
-                    'std': historical['humidity'].std(),
-                    'trend': humidity_trend.slope,
-                    'trend_r2': humidity_trend.rvalue**2,
-                    'recent_change': historical['humidity'].iloc[-1] - historical['humidity'].iloc[0]
-                },
-                'rainfall': {
-                    'mean': historical['rainfall'].mean(),
-                    'std': historical['rainfall'].std(),
-                    'trend': rainfall_trend.slope,
-                    'trend_r2': rainfall_trend.rvalue**2,
-                    'recent_change': historical['rainfall'].iloc[-1] - historical['rainfall'].iloc[0],
-                    'rainy_days': (historical['rainfall'] > 0.1).sum()  # Count days with significant rain
-                },
-                'ndvi': {
-                    'mean': historical['estimated_ndvi'].mean(),
-                    'std': historical['estimated_ndvi'].std(),
-                    'trend': ndvi_trend.slope,
-                    'trend_r2': ndvi_trend.rvalue**2,
-                    'recent_change': historical['estimated_ndvi'].iloc[-1] - historical['estimated_ndvi'].iloc[0]
-                }
-            }
-        }
-        
-        if not forecast.empty:
-            analysis['forecast'] = {
-                'temperature': {
-                    'mean': forecast['temperature'].mean(),
-                    'std': forecast['temperature'].std(),
-                    'range': forecast['temp_max'].mean() - forecast['temp_min'].mean()
-                },
-                'humidity': {
-                    'mean': forecast['humidity'].mean(),
-                    'std': forecast['humidity'].std()
-                },
-                'rainfall': {
-                    'mean': forecast['rainfall'].mean(),
-                    'std': forecast['rainfall'].std(),
-                    'rainy_days_expected': (forecast['rainfall'] > 0.1).sum()
-                },
-                'ndvi': {
-                    'mean': forecast['estimated_ndvi'].mean(),
-                    'std': forecast['estimated_ndvi'].std()
-                }
-            }
-        
-        return analysis
-            
-    except Exception as e:
-        print(f"Error in trend analysis: {e}")
-        return None
+```