Changes in deployment++++

requirements.txt

@@ -1,10 +1,10 @@
 fastapi
 uvicorn[standard]
-scikit-learn==1.2.2
+scikit-learn
 numpy
-xgboost==1.7.6
+xgboost
 joblib
-pandas==1.5.3
+pandas
 matplotlib
 httpx
 python-dotenv

routes/predictions.py

@@ -201,25 +201,22 @@ from services.weather_service import get_weather_data_for_city, AIR_QUALITY_MAP,
 import os
 import joblib
 import pandas as pd
-import numpy as np
-
 router = APIRouter()
 
+
 MODELS_DIR = 'models'
 models = {}
 
-# Ensure models dir exists and load models
+# Ensure models dir exists
 if os.path.exists(MODELS_DIR):
     for model_file in os.listdir(MODELS_DIR):
         if model_file.endswith('.pkl'):
             commodity_name = model_file.replace('.pkl', '').replace('_', '/')
-            try:
-                models[commodity_name] = joblib.load(os.path.join(MODELS_DIR, model_file))
-                print(f"✅ Model loaded for: {commodity_name}")
-            except Exception as e:
-                print(f"❌ Failed to load model {commodity_name}: {e}")
+            models[commodity_name] = joblib.load(os.path.join(MODELS_DIR, model_file))
+            print(f"✅ Model loaded for: {commodity_name}")
 
 try:
+    # Ensure your CSV is accessible
     DF_FULL = pd.read_csv('final_output.csv', parse_dates=['created_at'], index_col='created_at')
     print("✅ Dataset loaded.")
 except FileNotFoundError:
@@ -236,9 +233,15 @@ def predict_fertilizer(request: FertilizerPredictionRequest):
     
 @router.get("/api/predict/{commodity}")
 def predict_commodity_price(commodity: str):
+    # result = get_market_prediction(commodity)
+    # if "error" in result:
+    #     raise HTTPException(status_code=404, detail=result["error"])
+    # return result
+
     if DF_FULL is None:
         raise HTTPException(status_code=500, detail="Server Error: Dataset not loaded.")
         
+    # 2. Check if Model exists (Normalize to Upper Case)
     target_commodity = commodity.upper()
     
     if target_commodity not in models:
@@ -246,56 +249,45 @@ def predict_commodity_price(commodity: str):
 
     model = models[target_commodity]
 
-    # Check history
+    # 3. Check if we have history for this commodity
     df_commodity = DF_FULL[DF_FULL['commodity'].str.upper() == target_commodity]
     if df_commodity.empty:
          raise HTTPException(status_code=404, detail="No historical data found for commodity")
 
-    # Get last known date
+    # 4. Get the last known date
     df_daily = df_commodity.groupby(df_commodity.index).agg({'modal_price': 'mean'})
     last_known_date = df_daily.index.max()
 
-    # --- 1. Recent History Validation ---
+    # 5. Generate Recent History (for comparison chart)
+    # Get last 90 days of actual data
+    start_context_date = last_known_date - pd.Timedelta(days=90)
+    df_featured = _create_features(df_daily)
+    test_df = df_featured.loc[df_featured.index >= start_context_date]
+    
     recent_data = []
-    try:
-        start_context_date = last_known_date - pd.Timedelta(days=90)
-        df_featured = _create_features(df_daily)
-        test_df = df_featured.loc[df_featured.index >= start_context_date].dropna()
-        
-        if not test_df.empty:
-            FEATURES = [col for col in test_df.columns if col != 'modal_price']
-            
-            # FIX: Ensure DataFrame format for XGBoost
-            X_input = pd.DataFrame(test_df[FEATURES].values, columns=FEATURES, index=test_df.index)
-            
-            predictions = model.predict(X_input)
-            
+    if not test_df.empty:
+        FEATURES = [col for col in test_df.columns if col != 'modal_price']
+        try:
+            predictions = model.predict(test_df[FEATURES])
             for date, actual, pred in zip(test_df.index, test_df['modal_price'], predictions):
                 recent_data.append({
                     "date": date.strftime('%Y-%m-%d'),
                     "actual_price": float(actual),
                     "predicted_price": float(pred)
                 })
-    except Exception as e:
-        print(f"Warning: Could not generate history validation: {e}")
+        except Exception as e:
+            print(f"Warning: Could not generate history validation: {e}")
 
-    # --- 2. Future Forecast ---
-    future_data = []
+    # 6. Generate Future Forecast (Calling the helper function correctly!)
     try:
+        # HERE IS THE FIX: We pass all 4 arguments required by the helper
         daily_forecast_df = get_market_prediction(model, DF_FULL, target_commodity, last_known_date)
         
+        future_data = []
         for date, row in daily_forecast_df.iterrows():
-            price = row['forecast']
-            
-            # --- CRITICAL FIX: Handle NaN values safely ---
-            if pd.isna(price) or np.isnan(price):
-                final_price = None 
-            else:
-                final_price = float(price)
-                
             future_data.append({
                 "date": date.strftime('%Y-%m-%d'),
-                "forecast_price": final_price
+                "forecast_price": float(row['forecast'])
             })
             
     except Exception as e:
@@ -308,7 +300,12 @@ def predict_commodity_price(commodity: str):
         "forecast_data": future_data
     }
 
-@router.post("/api/marketPrice", response_model=List[MarketPriceData])
+@router.post(
+    "/api/marketPrice",
+    response_model=List[MarketPriceData],
+    summary="Fetch Agricultural Market Prices",
+    description="Retrieves daily market price data for a specific commodity, state, and APMC over the last 7 days."
+)
 async def get_market_price(request: MarketPriceRequest):
     market_data = await fetch_market_data(request)
     return market_data
@@ -317,12 +314,15 @@ async def get_market_price(request: MarketPriceRequest):
 async def get_current_weather(city: str):
     try:
         weather_data = await get_weather_data_for_city(city)
+
         current_data = weather_data.get("current", {})
         location_data = weather_data.get("location", {})
         air_quality_data = current_data.get("air_quality", {})
+        
         aqi_index = air_quality_data.get("us-epa-index")
+        air_quality_description = AIR_QUALITY_MAP.get(aqi_index, "Unknown")
         
-        return WeatherResponse(
+        response_data = WeatherResponse(
             location_name=location_data.get("name", "N/A"),
             temperature_c=current_data.get("temp_c"),
             condition=current_data.get("condition", {}).get("text", "N/A"),
@@ -330,22 +330,32 @@ async def get_current_weather(city: str):
             wind_kph=current_data.get("wind_kph"),
             cloud=current_data.get("cloud"), 
             is_day=current_data.get("is_day"),   
-            air_quality=AIR_QUALITY_MAP.get(aqi_index, "Unknown")
+            air_quality=air_quality_description
         )
+        
+        return response_data
+
     except HTTPException as e:
         raise e
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
+    
 
-@router.get("/weather/forecast/{city}", response_model=ForecastResponse)
-async def get_weather_forecast(city: str, days: int = Query(default=1, ge=1, le=14)):
+@router.get("/weather/forecast/{city}", response_model=ForecastResponse, summary="Get Weather Forecast")
+async def get_weather_forecast(city: str, days: int = Query(default=1, ge=1, le=14, description="Number of days to forecast (between 1 and 14).")):
+    """
+    Retrieves the weather forecast for a specific city for a given number of days.
+    """
     try:
         forecast_data = await get_weather_forecast_for_city(city, days)
+
         location_data = forecast_data.get("location", {})
+        forecast_days_raw = forecast_data.get("forecast", {}).get("forecastday", [])
+
         processed_forecast_days = []
-        for day_data in forecast_data.get("forecast", {}).get("forecastday", []):
+        for day_data in forecast_days_raw:
             day_details = day_data.get("day", {})
-            processed_forecast_days.append(DayForecast(
+            processed_day = DayForecast(
                 date=day_data.get("date"),
                 maxtemp_c=day_details.get("maxtemp_c"),
                 mintemp_c=day_details.get("mintemp_c"),
@@ -354,12 +364,16 @@ async def get_weather_forecast(city: str, days: int = Query(default=1, ge=1, le=
                 daily_chance_of_rain=day_details.get("daily_chance_of_rain", 0),
                 avghumidity=day_details.get("avghumidity", 0),
                 maxwind_kph=day_details.get("maxwind_kph", 0.0),
-            ))
-            
-        return ForecastResponse(
+            )
+            processed_forecast_days.append(processed_day)
+
+        response_data = ForecastResponse(
             location_name=location_data.get("name", "N/A"),
             forecast_days=processed_forecast_days
         )
+
+        return response_data
+
     except HTTPException as e:
         raise e
     except Exception as e:

services/market_services.py

@@ -10,18 +10,16 @@ from typing import List, Dict, Optional
 MODELS_DIR = 'models'
 models = {}
 
+# Ensure models dir exists
 if os.path.exists(MODELS_DIR):
     for model_file in os.listdir(MODELS_DIR):
         if model_file.endswith('.pkl'):
-            # Normalize filename to commodity name
             commodity_name = model_file.replace('.pkl', '').replace('_', '/')
-            try:
-                models[commodity_name] = joblib.load(os.path.join(MODELS_DIR, model_file))
-                print(f"✅ Model loaded for: {commodity_name}")
-            except Exception as e:
-                print(f"❌ Failed to load model {commodity_name}: {e}")
+            models[commodity_name] = joblib.load(os.path.join(MODELS_DIR, model_file))
+            print(f"✅ Model loaded for: {commodity_name}")
 
 try:
+    # Ensure your CSV is accessible
     DF_FULL = pd.read_csv('final_output.csv', parse_dates=['created_at'], index_col='created_at')
     print("✅ Dataset loaded.")
 except FileNotFoundError:
@@ -38,73 +36,57 @@ def _create_features(df):
     df['year'] = df.index.year
     df['quarter'] = df.index.quarter
     df['weekofyear'] = df.index.isocalendar().week.astype(int)
-    
-    # Lag features
+    # Lags and Rolling features
     df['price_lag_7'] = df['modal_price'].shift(7)
     df['price_lag_14'] = df['modal_price'].shift(14)
     df['price_lag_30'] = df['modal_price'].shift(30)
-    
-    # Rolling window features
     df['rolling_mean_30'] = df['modal_price'].shift(1).rolling(window=30).mean()
     df['rolling_std_30'] = df['modal_price'].shift(1).rolling(window=30).std()
-    
-    # CRITICAL: Do NOT dropna() here. We need the future row (which has NaNs) to survive
-    # so we can predict it.
-    return df
+    return df.dropna()
 
 def get_market_prediction(model, df_full, commodity, last_known_date):
     """
     Iteratively predicts the next 180 days.
     """
-    # 1. Filter data for the commodity
-    df_commodity = df_full[df_full['commodity'].str.upper() == commodity.upper()]
+    df_commodity = df_full[df_full['commodity'] == commodity]
     df_daily = df_commodity.groupby(df_commodity.index).agg({'modal_price': 'mean'})
     
-    # 2. Setup future dates
     future_dates = pd.date_range(start=last_known_date + pd.Timedelta(days=1), periods=180, freq='D')
     
+    # Create a container for future data
     future_df = pd.DataFrame(index=future_dates)
     future_df['modal_price'] = np.nan
     
-    # 3. Combine history and future placeholder
+    # Append future placeholder to history so we can calculate lags on the fly
     df_extended = pd.concat([df_daily, future_df])
     
-    # 4. Determine feature columns from a valid historical sample
-    valid_sample = _create_features(df_daily.tail(50)).dropna()
-    FEATURES = [col for col in valid_sample.columns if col != 'modal_price']
-
     for date in future_dates:
-        # We need historical context to calculate rolling averages/lags
+        # Create features for the specific day (uses previous days' data for lags)
+        # Note: We take a slice up to 'date' to generate features dynamically
         subset = df_extended.loc[:date]
+        if len(subset) < 30: continue # Safety check for rolling windows
         
-        # Safety check: ensure we have enough data for 30-day rolling window
-        if len(subset) < 35: continue 
+        featured_row = _create_features(subset).iloc[-1:]
         
-        # Generate features
-        featured_subset = _create_features(subset)
+        if featured_row.empty: continue
+
+        FEATURES = [col for col in featured_row.columns if col != 'modal_price']
         
-        # Get the row for the prediction date
-        if date not in featured_subset.index: continue
-        featured_row = featured_subset.loc[[date]]
+        # Predict
+        prediction = model.predict(featured_row[FEATURES])[0]
         
-        # --- FIX: Ensure strict DataFrame format for XGBoost ---
-        try:
-            # Reconstruct DataFrame with explicit columns to satisfy XGBoost
-            X_input = pd.DataFrame(featured_row[FEATURES].values, columns=FEATURES, index=featured_row.index)
-            
-            prediction = model.predict(X_input)[0]
-            df_extended.loc[date, 'modal_price'] = prediction
-        except Exception as e:
-            # If prediction fails, we break. The NaNs will remain and be handled by the route.
-            print(f"Prediction error for {date}: {e}")
-            break
+        # Update the dataframe so the next loop can use this prediction for its lag features
+        df_extended.loc[date, 'modal_price'] = prediction
     
+    # Extract just the future part
     daily_forecast_df = df_extended.loc[future_dates].copy()
     daily_forecast_df.rename(columns={'modal_price': 'forecast'}, inplace=True)
     
     return daily_forecast_df
 
 
+
+
 # import pandas as pd
 # import numpy as np
 # import joblib