First commit

Dockerfile

@@ -0,0 +1,28 @@
+# Use Python 3.12 based on your pycache version
+FROM python:3.12
+
+# Set the working directory to /app
+WORKDIR /app
+
+# Copy the requirements file and install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Create a non-root user for security (Required by HF Spaces)
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+# Copy the rest of the application code
+COPY --chown=user . .
+
+# Run the setup script to download models from your HF Repo
+# This happens during the build/start phase
+RUN python setup_models.py
+
+# Expose the port Hugging Face Spaces expects (7860)
+EXPOSE 7860
+
+# Command to run the application
+# 0.0.0.0 is required for Docker containers to be accessible
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

main.py

@@ -0,0 +1,25 @@
+from fastapi import FastAPI
+from routes import predictions
+from fastapi.middleware.cors import CORSMiddleware
+
+
+app = FastAPI()
+
+origins = [
+    "http://127.0.0.1:5173", # Add Vite default port
+    "http://localhost:5173",
+    "http://127.0.0.1:5501", 
+    "http://localhost:5501",
+    "http://127.0.0.1:5500",
+    "http://localhost:5500",
+]
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,  # Allows specific origins
+    allow_credentials=True,
+    allow_methods=["*"],    # Allows all methods (GET, POST, etc.)
+    allow_headers=["*"],    # Allows all headers
+)
+
+app.include_router(predictions.router)

requirements.txt

@@ -0,0 +1,11 @@
+fastapi
+uvicorn[standard]
+scikit-learn
+numpy
+xgboost
+joblib
+pandas
+matplotlib
+httpx
+python-dotenv
+huggingface-hub

routes/predictions.py

@@ -0,0 +1,189 @@
+from fastapi import APIRouter, HTTPException, Query
+from typing import List
+from schemas.prediction_schemas import CropPredictionRequest, FertilizerPredictionRequest
+from services.prediction_services import get_crop_prediction, get_fertilizer_prediction
+from services.market_services import get_market_prediction, _create_features
+from services.marketTracking_services import fetch_market_data
+from schemas.marketTracker_schemas import MarketPriceRequest, MarketPriceData
+from schemas.weather_schemas import WeatherResponse, ForecastResponse, DayForecast
+from services.weather_service import get_weather_data_for_city, AIR_QUALITY_MAP, get_weather_forecast_for_city
+import os
+import joblib
+import pandas as pd
+router = APIRouter()
+
+
+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'):
+            commodity_name = model_file.replace('.pkl', '').replace('_', '/')
+            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:
+    print("❌ 'final_output.csv' not found. Predictions will fail.")
+    DF_FULL = None 
+
+@router.post("/api/predict_crop")
+def predict_crop(request: CropPredictionRequest):
+    return get_crop_prediction(request)
+
+@router.post("/api/predict_fertilizer")
+def predict_fertilizer(request: FertilizerPredictionRequest):
+    return get_fertilizer_prediction(request)
+    
+@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:
+        raise HTTPException(status_code=404, detail=f"Model for '{commodity}' not found.")
+
+    model = models[target_commodity]
+
+    # 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")
+
+    # 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()
+
+    # 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 = []
+    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}")
+
+    # 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():
+            future_data.append({
+                "date": date.strftime('%Y-%m-%d'),
+                "forecast_price": float(row['forecast'])
+            })
+            
+    except Exception as e:
+        print(f"Forecast Error: {e}")
+        raise HTTPException(status_code=500, detail=f"Prediction failed: {str(e)}")
+
+    return {
+        "commodity": commodity,
+        "recent_data": recent_data,
+        "forecast_data": future_data
+    }
+
+@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
+
+@router.get("/weather/{city}", response_model=WeatherResponse)
+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")
+        
+        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"),
+            humidity=current_data.get("humidity"),
+            wind_kph=current_data.get("wind_kph"),
+            cloud=current_data.get("cloud"), 
+            is_day=current_data.get("is_day"),   
+            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, 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_days_raw:
+            day_details = day_data.get("day", {})
+            processed_day = DayForecast(
+                date=day_data.get("date"),
+                maxtemp_c=day_details.get("maxtemp_c"),
+                mintemp_c=day_details.get("mintemp_c"),
+                avgtemp_c=day_details.get("avgtemp_c"),
+                condition=day_details.get("condition", {}).get("text", "N/A"),
+                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),
+            )
+            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:
+        raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")

schemas/marketTracker_schemas.py

@@ -0,0 +1,30 @@
+from pydantic import BaseModel, Field
+from typing import Union
+
+class MarketPriceRequest(BaseModel):
+    commodity_name: str = Field(..., example="Potato")
+    state_name: str = Field(..., example="UTTAR PRADESH")
+    apmc_name: str = Field(..., example="AGRA")
+
+class MarketPriceData(BaseModel):
+    # We map our desired field 'date' to the API's 'created_at' field.
+    date: str = Field(..., alias="created_at", example="2025-09-16")
+    
+    # The API sends these as strings, so we accept them as Union[str, float] for safety.
+    modal_price: Union[str, float] = Field(..., alias="modal_price")
+    min_price: Union[str, float] = Field(..., alias="min_price")
+    max_price: Union[str, float] = Field(..., alias="max_price")
+    
+    # Map our fields to the API's fields
+    total_arrival: str = Field(..., alias="commodity_arrivals")
+    total_trade: str = Field(..., alias="commodity_traded")
+    
+    commodity: str = Field(..., alias="commodity")
+    apmc: str = Field(..., alias="apmc")
+
+    class Config:
+        # This allows Pydantic to create the model from a dictionary
+        from_attributes = True
+        # This is CRITICAL: it tells Pydantic to use the 'alias' names when reading the data
+        populate_by_name = True
+

schemas/market_schemas.py

@@ -0,0 +1,9 @@
+from pydantic import BaseModel
+from typing import Dict
+
+class MarketPriceInput(BaseModel):
+    commodity: str
+
+class MarketPriceOutput(BaseModel):
+    commodity: str
+    forecast: Dict[str, float]

schemas/prediction_schemas.py

@@ -0,0 +1,21 @@
+from pydantic import BaseModel
+
+class CropPredictionRequest(BaseModel):
+    Nitrogen: float
+    Phosphorus: float
+    Potassium: float
+    temperature: float
+    humidity: float
+    ph: float
+    rainfall: float
+
+class FertilizerPredictionRequest(BaseModel):
+    Nitrogen: float
+    Phosphorus: float
+    Potassium: float
+    temperature: float
+    humidity: float
+    moisture: float
+    crop_type: str
+    soil_type: str
+

schemas/weather_schemas.py

@@ -0,0 +1,46 @@
+from pydantic import BaseModel
+from typing import List
+
+class WeatherResponse(BaseModel):
+    """
+    Defines the updated structure for the weather data response.
+    """
+    location_name: str
+    temperature_c: float
+    condition: str
+    humidity: int
+    wind_kph: float
+    # New fields added below
+    cloud: int
+    is_day: int # Will be 1 for day, 0 for night
+    air_quality: str
+
+    class Config:
+        from_attributes = True
+
+
+class DayForecast(BaseModel):
+    """
+    Defines the structure for a single day's forecast.
+    """
+    date: str
+    maxtemp_c: float
+    mintemp_c: float
+    avgtemp_c: float
+    condition: str
+    daily_chance_of_rain: int
+    avghumidity: int
+    maxwind_kph: float
+
+    class Config:
+        from_attributes = True
+
+class ForecastResponse(BaseModel):
+    """
+    Defines the overall structure for the weather forecast response.
+    """
+    location_name: str
+    forecast_days: List[DayForecast]
+
+    class Config:
+        from_attributes = True

services/marketTracking_services.py

@@ -0,0 +1,52 @@
+import httpx
+from datetime import date, timedelta
+from fastapi import HTTPException
+from schemas.marketTracker_schemas import MarketPriceRequest, MarketPriceData
+
+# The external API endpoint we are fetching data from
+ENAM_API_URL = "https://enam.gov.in/web/Ajax_ctrl/trade_data_list"
+
+async def fetch_market_data(request: MarketPriceRequest) -> list[MarketPriceData]:
+    
+    today = date.today()
+    start_date = today - timedelta(days=6)
+    
+    start_date_str = start_date.strftime("%Y-%m-%d")
+    end_date_str = today.strftime("%Y-%m-%d")
+
+    payload = {
+        "language": "en",
+        "stateName": request.state_name,
+        "apmcName": request.apmc_name,
+        "commodityName": request.commodity_name,
+        "fromDate": start_date_str,
+        "toDate": end_date_str,
+    }
+    
+    headers = {
+        "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
+        "X-Requested-With": "XMLHttpRequest"
+    }
+
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.post(ENAM_API_URL, data=payload, headers=headers, timeout=10.0)
+            response.raise_for_status() 
+            
+            json_data = response.json()
+            api_rows = json_data.get("data", [])
+
+            if not api_rows:
+                return []
+
+            validated_data = [MarketPriceData.model_validate(row) for row in api_rows]
+            return validated_data
+
+        except httpx.RequestError as exc:
+            print(f"An error occurred while requesting {exc.request.url!r}.")
+            raise HTTPException(status_code=502, detail=f"Failed to communicate with eNAM portal: {exc}")
+        except Exception as e:
+            print(f"An unexpected error occurred: {e}")
+            raise HTTPException(status_code=500, detail="An internal server error occurred.")
+
+

services/market_services.py

@@ -0,0 +1,200 @@
+# import pandas as pd
+# import numpy as np
+# import matplotlib.pyplot as plt
+# import joblib
+# import os
+# import io
+# import base64
+
+# MODELS_DIR = 'models'
+# models = {}
+# for model_file in os.listdir(MODELS_DIR):
+#     if model_file.endswith('.pkl'):
+#         commodity_name = model_file.replace('.pkl', '').replace('_', '/')
+#         models[commodity_name] = joblib.load(os.path.join(MODELS_DIR, model_file))
+#         print(f"✅ Model loaded for: {commodity_name}")
+
+
+# try:
+#     DF_FULL = pd.read_csv('final_output.csv', parse_dates=['created_at'], index_col='created_at')
+#     print("✅ Dataset loaded and indexed by 'created_at'.")
+# except FileNotFoundError:
+#     print("'your_dataset.csv' not found. The application cannot start.")
+#     DF_FULL = None 
+
+
+# def _create_features(df):
+#     df = df.copy()
+#     df['dayofweek'] = df.index.dayofweek
+#     df['dayofyear'] = df.index.dayofyear
+#     df['month'] = df.index.month
+#     df['year'] = df.index.year
+#     df['quarter'] = df.index.quarter
+#     df['weekofyear'] = df.index.isocalendar().week.astype(int)
+#     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)
+#     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()
+#     return df.dropna()
+
+# def _forecast_six_months(model, df_full, commodity, last_known_date):
+#     df_commodity = df_full[df_full['commodity'] == commodity]
+#     df_daily = df_commodity.groupby(df_commodity.index).agg({'modal_price': 'mean'})
+    
+#     future_dates = pd.date_range(start=last_known_date + pd.Timedelta(days=1), periods=180, freq='D')
+#     future_df = pd.DataFrame(index=future_dates)
+#     future_df['modal_price'] = np.nan
+#     df_extended = pd.concat([df_daily, future_df])
+    
+#     for date in future_dates:
+#         featured_row = _create_features(df_extended.loc[:date]).iloc[-1:]
+#         FEATURES = [col for col in featured_row.columns if col != 'modal_price']
+#         prediction = model.predict(featured_row[FEATURES])[0]
+#         df_extended.loc[date, 'modal_price'] = prediction
+    
+#     daily_forecast_df = df_extended.loc[future_dates].copy()
+#     daily_forecast_df.rename(columns={'modal_price': 'forecast'}, inplace=True)
+#     return daily_forecast_df
+
+# def get_market_prediction(commodity: str):
+
+#     if DF_FULL is None:
+#         return {"error": "Dataset not found. Please check server configuration."}
+        
+#     if commodity not in models:
+#         return {"error": f"Model for commodity '{commodity}' not found."}
+
+#     model = models[commodity]
+
+#     # Prepare data for the specific commodity
+#     df_commodity = DF_FULL[DF_FULL['commodity'] == commodity]
+#     df_daily = df_commodity.groupby(df_commodity.index).agg({'modal_price': 'mean'})
+#     df_featured = _create_features(df_daily)
+    
+#     test_df = df_featured.loc[df_featured.index >= '2024-01-01']
+#     if test_df.empty:
+#         return {"error": f"Not enough recent data to make a prediction for '{commodity}'."}
+
+#     FEATURES = [col for col in test_df.columns if col != 'modal_price']
+#     TARGET = 'modal_price'
+#     X_test, y_test = test_df[FEATURES], test_df[TARGET]
+
+#     predictions = model.predict(X_test)
+
+#     last_known_date = test_df.index.max()
+#     daily_forecast_df = _forecast_six_months(model, DF_FULL, commodity, last_known_date)
+#     monthly_forecast_df = daily_forecast_df.resample('ME').last().head(6)
+
+#     plt.figure(figsize=(12, 6))
+#     plt.style.use('seaborn-v0_8-whitegrid')
+#     plt.plot(y_test.index, y_test, label='Actual Price (Recent History)', color='green', linewidth=2)
+#     plt.plot(y_test.index, predictions, label='Model Prediction (on Recent History)', color='red', linestyle='--')
+#     plt.plot(daily_forecast_df.index, daily_forecast_df['forecast'], label='6-Month Forecast', color='purple', linestyle=':')
+#     plt.title(f'{commodity} Price: History, Prediction & Forecast', fontsize=16)
+#     plt.xlabel('Date')
+#     plt.ylabel('Modal Price')
+#     plt.legend()
+#     plt.tight_layout() 
+
+#     buf = io.BytesIO()
+#     plt.savefig(buf, format='png')
+#     buf.seek(0)
+#     plot_base64 = base64.b64encode(buf.read()).decode('utf-8')
+#     plt.close() 
+
+#     formatted_forecast = monthly_forecast_df.reset_index().rename(columns={'index': 'date'}).to_dict('records')
+
+#     return {
+#         "commodity": commodity,
+#         "monthly_forecast": formatted_forecast,
+#         "plot_base64": plot_base64
+#     }
+
+
+import pandas as pd
+import numpy as np
+import joblib
+import os
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from typing import List, Dict, Optional
+
+# --- Load Models & Data ---
+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'):
+            commodity_name = model_file.replace('.pkl', '').replace('_', '/')
+            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:
+    print("❌ 'final_output.csv' not found. Predictions will fail.")
+    DF_FULL = None 
+
+# --- Helper Functions ---
+
+def _create_features(df):
+    df = df.copy()
+    df['dayofweek'] = df.index.dayofweek
+    df['dayofyear'] = df.index.dayofyear
+    df['month'] = df.index.month
+    df['year'] = df.index.year
+    df['quarter'] = df.index.quarter
+    df['weekofyear'] = df.index.isocalendar().week.astype(int)
+    # 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)
+    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()
+    return df.dropna()
+
+def get_market_prediction(model, df_full, commodity, last_known_date):
+    """
+    Iteratively predicts the next 180 days.
+    """
+    df_commodity = df_full[df_full['commodity'] == commodity]
+    df_daily = df_commodity.groupby(df_commodity.index).agg({'modal_price': 'mean'})
+    
+    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
+    
+    # Append future placeholder to history so we can calculate lags on the fly
+    df_extended = pd.concat([df_daily, future_df])
+    
+    for date in future_dates:
+        # 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
+        
+        featured_row = _create_features(subset).iloc[-1:]
+        
+        if featured_row.empty: continue
+
+        FEATURES = [col for col in featured_row.columns if col != 'modal_price']
+        
+        # Predict
+        prediction = model.predict(featured_row[FEATURES])[0]
+        
+        # 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
+

services/prediction_services.py

@@ -0,0 +1,240 @@
+import joblib
+import numpy as np
+import os
+
+current_dir = os.path.dirname(os.path.abspath(__file__))
+
+models_dir = os.path.join(current_dir, '..', 'models')
+
+crop_prediction_model = joblib.load(os.path.join(models_dir, 'crop_prediction_model.pkl'))
+crop_prediction_scaler = joblib.load(os.path.join(models_dir, 'crop_prediction_scaler.pkl'))
+
+fertilizer_prediction_model = joblib.load(os.path.join(models_dir, 'fertilizer_prediction_model.pkl'))
+fertilizer_prediction_scaler = joblib.load(os.path.join(models_dir, 'fertilizer_prediction_scaler.pkl'))
+crop_encoder = joblib.load(os.path.join(models_dir, 'crop_encoder.pkl'))
+soil_encoder = joblib.load(os.path.join(models_dir, 'soil_encoder.pkl'))
+fertilizer_encoder = joblib.load(os.path.join(models_dir, 'fertilizer_encoder.pkl'))
+
+
+def get_crop_prediction(data):
+    features = np.array([[
+        data.Nitrogen,
+        data.Phosphorus,
+        data.Potassium,
+        data.temperature,
+        data.humidity,
+        data.ph,
+        data.rainfall
+    ]])
+    scaled_features = crop_prediction_scaler.transform(features)
+    prediction = crop_prediction_model.predict(scaled_features)
+    return {"predicted_crop": prediction[0]}
+
+
+def get_fertilizer_prediction(data):
+    crop_encoded = crop_encoder.transform(np.array([[data.crop_type]]))
+    soil_encoded = soil_encoder.transform(np.array([[data.soil_type]]))
+    features = np.array([[
+        data.temperature,
+        data.humidity,
+        data.moisture,
+        data.Nitrogen,
+        data.Potassium,
+        data.Phosphorus
+    ]])
+    scaled_features = fertilizer_prediction_scaler.transform(features)
+    final_features = np.concatenate([scaled_features, [soil_encoded], [crop_encoded]], axis=1)
+    prediction_encoded = fertilizer_prediction_model.predict(final_features)
+    prediction = fertilizer_encoder.inverse_transform(prediction_encoded)
+
+    return {"predicted_fertilizer": prediction[0]}
+
+
+
+# import joblib
+# import numpy as np
+# import os
+
+# current_dir = os.path.dirname(os.path.abspath(__file__))
+
+# models_dir = os.path.join(current_dir, '..', 'models')
+
+# crop_prediction_model = joblib.load(os.path.join(models_dir, 'crop_prediction_model.pkl'))
+# crop_prediction_scaler = joblib.load(os.path.join(models_dir, 'crop_prediction_scaler.pkl'))
+
+# fertilizer_prediction_model = joblib.load(os.path.join(models_dir, 'fertilizer_prediction_model.pkl'))
+# fertilizer_prediction_scaler = joblib.load(os.path.join(models_dir, 'fertilizer_prediction_scaler.pkl'))
+# crop_encoder = joblib.load(os.path.join(models_dir, 'crop_encoder.pkl'))
+# soil_encoder = joblib.load(os.path.join(models_dir, 'soil_encoder.pkl'))
+# fertilizer_encoder = joblib.load(os.path.join(models_dir, 'fertilizer_encoder.pkl'))
+
+
+# def get_crop_prediction(data):
+#     features = np.array([[
+#         data.Nitrogen,
+#         data.Phosphorous,
+#         data.Potassium,
+#         data.temperature,
+#         data.humidity,
+#         data.ph,
+#         data.rainfall
+#     ]])
+#     scaled_features = crop_prediction_scaler.transform(features)
+#     prediction = crop_prediction_model.predict(scaled_features)
+#     return {"predicted_crop": prediction[0]}
+
+
+# def get_fertilizer_prediction(data):
+#     crop_encoded = crop_encoder.transform(np.array([[data.crop_type]]))
+#     soil_encoded = soil_encoder.transform(np.array([[data.soil_type]]))
+#     features = np.array([[
+#         data.Temperature,
+#         data.Humidity,
+#         data.Moisture,
+#         data.Nitrogen,
+#         data.Potassium,
+#         data.Phosphorus
+#     ]])
+#     scaled_features = fertilizer_prediction_scaler.transform(features)
+#     final_features = np.concatenate([scaled_features, [soil_encoded], [crop_encoded]], axis=1)
+#     prediction_encoded = fertilizer_prediction_model.predict(final_features)
+#     prediction = fertilizer_encoder.inverse_transform(prediction_encoded)
+
+#     return {"predicted_fertilizer": prediction[0]}
+
+
+
+
+# # import joblib
+# # import numpy as np
+# # import os
+
+# # # Get the absolute path to the current file's directory
+# # current_dir = os.path.dirname(os.path.abspath(__file__))
+
+# # # Construct the absolute path to the models directory
+# # models_dir = os.path.join(current_dir, '..', 'models')
+
+# # # Load crop prediction model and scaler
+# # crop_prediction_model = joblib.load(os.path.join(models_dir, 'crop_prediction_model.pkl'))
+# # crop_prediction_scaler = joblib.load(os.path.join(models_dir, 'crop_prediction_scaler.pkl'))
+
+# # # Load fertilizer prediction model and encoders/scalers
+# # fertilizer_prediction_model = joblib.load(os.path.join(models_dir, 'fertilizer_prediction_model.pkl'))
+# # fertilizer_prediction_scaler = joblib.load(os.path.join(models_dir, 'fertilizer_prediction_scaler.pkl'))
+# # crop_encoder = joblib.load(os.path.join(models_dir, 'crop_encoder.pkl'))
+# # soil_encoder = joblib.load(os.path.join(models_dir, 'soil_encoder.pkl'))
+# # fertilizer_encoder = joblib.load(os.path.join(models_dir, 'fertilizer_encoder.pkl'))
+
+
+# # def get_crop_prediction(data):
+# #     """
+# #     Predicts the recommended crop based on soil and weather conditions.
+# #     """
+# #     features = np.array([[
+# #         data.Nitrogen,
+# #         data.Phosphorous,
+# #         data.Potassium,
+# #         data.temperature,
+# #         data.humidity,
+# #         data.ph,
+# #         data.rainfall
+# #     ]])
+# #     scaled_features = crop_prediction_scaler.transform(features)
+# #     prediction = crop_prediction_model.predict(scaled_features)
+# #     return {"predicted_crop": prediction[0]}
+
+
+# # def get_fertilizer_prediction(data):
+# #     """
+# #     Predicts the recommended fertilizer based on soil, weather, and crop type.
+# #     """
+# #     soil_encoded = soil_encoder.transform(np.array([[data.soil_type]]))
+# #     crop_encoded = crop_encoder.transform(np.array([[data.crop_type]]))
+
+# #     features = np.array([[
+# #         data.Nitrogen,
+# #         data.Phosphorus,
+# #         data.Potassium,
+# #         data.Temperature,
+# #         data.Humidity,
+# #         data.Moisture
+# #     ]])
+
+# #     scaled_features = fertilizer_prediction_scaler.transform(features)
+
+# #     final_features = np.concatenate([scaled_features, [soil_encoded], [crop_encoded]], axis=1)
+
+# #     prediction_encoded = fertilizer_prediction_model.predict(final_features)
+# #     prediction = fertilizer_encoder.inverse_transform(prediction_encoded)
+
+# #     return {"predicted_fertilizer": prediction[0]}
+
+
+# import joblib
+# import numpy as np
+# import os
+
+# # Get the absolute path to the current file's directory
+# current_dir = os.path.dirname(os.path.abspath(__file__))
+
+# # Construct the absolute path to the models directory
+# models_dir = os.path.join(current_dir, '..', 'models')
+
+# # Load crop prediction model and scaler
+# crop_prediction_model = joblib.load(os.path.join(models_dir, 'crop_prediction_model.pkl'))
+# crop_prediction_scaler = joblib.load(os.path.join(models_dir, 'crop_prediction_scaler.pkl'))
+
+# # Load fertilizer prediction model and encoders/scalers
+# fertilizer_prediction_model = joblib.load(os.path.join(models_dir, 'fertilizer_prediction_model.pkl'))
+# fertilizer_prediction_scaler = joblib.load(os.path.join(models_dir, 'fertilizer_prediction_scaler.pkl'))
+# crop_encoder = joblib.load(os.path.join(models_dir, 'crop_encoder.pkl'))
+# soil_encoder = joblib.load(os.path.join(models_dir, 'soil_encoder.pkl'))
+# fertilizer_encoder = joblib.load(os.path.join(models_dir, 'fertilizer_encoder.pkl'))
+
+
+# def get_crop_prediction(data):
+#     """
+#     Predicts the recommended crop based on soil and weather conditions.
+#     """
+#     features = np.array([[
+#         data.Nitrogen,
+#         data.Phosphorous,
+#         data.Potassium,
+#         data.temperature,
+#         data.humidity,
+#         data.ph,
+#         data.rainfall
+#     ]])
+#     scaled_features = crop_prediction_scaler.transform(features)
+#     prediction = crop_prediction_model.predict(scaled_features)
+#     return {"predicted_crop": prediction[0]}
+
+
+# def get_fertilizer_prediction(data):
+#     """
+#     Predicts the recommended fertilizer based on soil, weather, and crop type.
+#     """
+#     soil_encoded = soil_encoder.transform(np.array([[data.soil_type]]))
+#     crop_encoded = crop_encoder.transform(np.array([[data.crop_type]]))
+
+#     features = np.array([[
+#         data.Nitrogen,
+#         data.Phosphorus,
+#         data.Potassium,
+#         data.Temperature,
+#         data.Humidity,
+#         data.Moisture
+#     ]])
+
+#     scaled_features = fertilizer_prediction_scaler.transform(features)
+
+#     final_features = np.concatenate([scaled_features, [soil_encoded], [crop_encoded]], axis=1)
+
+#     prediction_encoded = fertilizer_prediction_model.predict(final_features)
+#     prediction = fertilizer_encoder.inverse_transform(prediction_encoded)
+
+#     return {"predicted_fertilizer": prediction[0]}
+
+
+

services/weather_service.py

@@ -0,0 +1,66 @@
+import os
+import httpx
+from fastapi import HTTPException
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Get the API key from environment variables
+API_KEY = os.getenv("WEATHER_API_KEY")
+if not API_KEY:
+    raise ValueError("No WEATHER_API_KEY found in environment variables")
+
+BASE_URL = "http://api.weatherapi.com/v1/current.json"
+
+AIR_QUALITY_MAP = {
+    1: "Good",
+    2: "Moderate",
+    3: "Unhealthy for sensitive groups",
+    4: "Unhealthy",
+    5: "Very Unhealthy",
+    6: "Hazardous",
+}
+
+async def get_weather_data_for_city(city: str) -> dict:
+    
+    params = {"key": API_KEY, "q": city, "aqi": "yes"}
+    
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.get(BASE_URL, params=params)
+            
+            # Raise an exception for bad status codes (4xx or 5xx)
+            response.raise_for_status() 
+            
+            return response.json()
+            
+        except httpx.HTTPStatusError as e:
+            # Handle specific API error responses
+            if e.response.status_code == 400:
+                raise HTTPException(status_code=404, detail=f"City '{city}' not found.")
+            else:
+                raise HTTPException(status_code=e.response.status_code, detail="Error fetching weather data.")
+        except httpx.RequestError:
+            # Handle network-related errors
+            raise HTTPException(status_code=503, detail="Service is unavailable.")
+        
+async def get_weather_forecast_for_city(city: str, days: int) -> dict:
+    """
+    Fetches the weather forecast for a given city and number of days.
+    """
+    url = f"{BASE_URL}/forecast.json"
+    params = {"key": API_KEY, "q": city, "days": days, "aqi": "no", "alerts": "no"}
+    
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.get(url, params=params)
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 400:
+                raise HTTPException(status_code=404, detail=f"City '{city}' not found.")
+            else:
+                raise HTTPException(status_code=e.response.status_code, detail="Error fetching weather forecast data.")
+        except httpx.RequestError:
+            raise HTTPException(status_code=503, detail="Service is unavailable.")

setup_models.py

@@ -0,0 +1,74 @@
+# setup_models.py
+import os
+import shutil
+from huggingface_hub import hf_hub_download, snapshot_download
+
+# Configuration
+REPO_ID = "ShadowGard3n/AgroVision-Models"
+DEST_MODELS_DIR = "models"
+
+# Ensure the destination models directory exists
+os.makedirs(DEST_MODELS_DIR, exist_ok=True)
+
+print(f"--- Starting Download from {REPO_ID} ---")
+
+# 1. Download final_output.csv to the root directory
+try:
+    print("Downloading final_output.csv...")
+    hf_hub_download(
+        repo_id=REPO_ID,
+        filename="final_output.csv",
+        local_dir=".",
+        local_dir_use_symlinks=False
+    )
+    print("✅ final_output.csv downloaded.")
+except Exception as e:
+    print(f"❌ Error downloading csv: {e}")
+
+# 2. Download 'market_models' folder and move files to 'models/'
+try:
+    print("Downloading market_models...")
+    market_path = snapshot_download(
+        repo_id=REPO_ID,
+        allow_patterns="market_models/*",
+        local_dir="temp_download",
+        local_dir_use_symlinks=False
+    )
+    
+    # Move files from temp_download/market_models to models/
+    source_dir = os.path.join(market_path, "market_models")
+    if os.path.exists(source_dir):
+        for file_name in os.listdir(source_dir):
+            full_file_name = os.path.join(source_dir, file_name)
+            if os.path.isfile(full_file_name):
+                shutil.move(full_file_name, DEST_MODELS_DIR)
+    print("✅ Market models moved to /models.")
+except Exception as e:
+    print(f"❌ Error downloading market models: {e}")
+
+# 3. Download 'other_models' folder and move files to 'models/'
+try:
+    print("Downloading other_models...")
+    other_path = snapshot_download(
+        repo_id=REPO_ID,
+        allow_patterns="other_models/*",
+        local_dir="temp_download_other",
+        local_dir_use_symlinks=False
+    )
+    
+    # Move files from temp_download_other/other_models to models/
+    source_dir = os.path.join(other_path, "other_models")
+    if os.path.exists(source_dir):
+        for file_name in os.listdir(source_dir):
+            full_file_name = os.path.join(source_dir, file_name)
+            if os.path.isfile(full_file_name):
+                shutil.move(full_file_name, DEST_MODELS_DIR)
+    print("✅ Other models moved to /models.")
+except Exception as e:
+    print(f"❌ Error downloading other models: {e}")
+
+# Cleanup temp folders
+shutil.rmtree("temp_download", ignore_errors=True)
+shutil.rmtree("temp_download_other", ignore_errors=True)
+
+print("--- Setup Complete ---")

train_market_model.py

@@ -0,0 +1,185 @@
+# needs to run only once
+
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import xgboost as xgb
+from sklearn.metrics import mean_absolute_error, r2_score
+import joblib
+import os
+
+class CommodityPricePredictor:
+    def __init__(self, df):
+        if not isinstance(df.index, pd.DatetimeIndex):
+            try:
+                df['created_at'] = pd.to_datetime(df['created_at'])
+                df = df.set_index('created_at')
+            except (KeyError, TypeError):
+                raise TypeError("DataFrame must have a DatetimeIndex or a 'created_at' column to convert.")
+        self.df_full = df.copy().sort_index()
+        self.models = {} # to store a trained model for each commodity
+        print("✅ Predictor initialized.")
+
+    def _create_features(self, df):
+        df = df.copy()
+        df['dayofweek'] = df.index.dayofweek
+        df['dayofyear'] = df.index.dayofyear
+        df['month'] = df.index.month
+        df['year'] = df.index.year
+        df['quarter'] = df.index.quarter
+        df['weekofyear'] = df.index.isocalendar().week.astype(int)
+
+        # Lag features (price from previous periods)
+        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 (trend over the last month)
+        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()
+
+        return df.dropna()
+
+    def train(self, commodity):
+        """
+        Trains a new XGBoost model for a specific commodity.
+        """
+        print(f"--- Training model for: {commodity} ---")
+
+        df_commodity = self.df_full[self.df_full['commodity'] == commodity]
+        if df_commodity.empty:
+            print(f" Warning: No data found for {commodity}. Skipping training.")
+            return
+
+        df_daily = df_commodity.groupby(df_commodity.index).agg({
+            'modal_price': 'mean' # Use the average price for that day
+        })
+
+        df_featured = self._create_features(df_daily)
+
+        train_df = df_featured.loc[df_featured.index < '2024-01-01']
+        test_df = df_featured.loc[df_featured.index >= '2024-01-01']
+
+        if test_df.empty or train_df.empty:
+            print(f"⚠️ Warning: Not enough data to perform train/test split for {commodity}.")
+            return
+
+        print(f"Training data from {train_df.index.min().date()} to {train_df.index.max().date()}")
+        print(f"Testing data from {test_df.index.min().date()} to {test_df.index.max().date()}")
+
+        FEATURES = [col for col in df_featured.columns if col != 'modal_price']
+        TARGET = 'modal_price'
+
+        X_train, y_train = train_df[FEATURES], train_df[TARGET]
+        X_test, y_test = test_df[FEATURES], test_df[TARGET]
+
+        model = xgb.XGBRegressor(
+            n_estimators=1000,
+            learning_rate=0.01,
+            eval_metric='mae',
+            early_stopping_rounds=20
+        )
+
+        model.fit(X_train, y_train,
+                    eval_set=[(X_test, y_test)],
+                    verbose=False)
+
+        self.models[commodity] = model
+        print(f"✅ Model for {commodity} trained and stored.")
+        self.evaluate(commodity, test_df) # Evaluate right after training
+
+    def evaluate(self, commodity, test_df):
+        if commodity not in self.models:
+            print(f"❌ Error: Model for {commodity} not found. Please train it first.")
+            return
+
+        model = self.models[commodity]
+        FEATURES = [col for col in test_df.columns if col != 'modal_price']
+        TARGET = 'modal_price'
+
+        X_test, y_test = test_df[FEATURES], test_df[TARGET]
+        predictions = model.predict(X_test)
+
+        mae = mean_absolute_error(y_test, predictions)
+        r2 = r2_score(y_test, predictions)
+
+        print(f"\n--- Evaluation Results for {commodity} ---")
+        print(f"R-squared (R²): {r2:.3f}")
+        print(f"Mean Absolute Error (MAE): {mae:.2f}")
+        print("--------------------------------------")
+
+        daily_forecast_df, monthly_forecast_df = self.forecast_six_months(commodity, test_df.index.max())
+
+        # plt.figure(figsize=(15, 6))
+        # plt.style.use('seaborn-v0_8-whitegrid')
+        # plt.plot(y_test.index, y_test, label='Actual Price', color='green')
+        # plt.plot(y_test.index, predictions, label='Predicted Price (on test data)', color='red', linestyle='--')
+        
+        # if daily_forecast_df is not None and not daily_forecast_df.empty:
+        #     plt.plot(daily_forecast_df.index, daily_forecast_df['forecast'], 
+        #                 label='6-Month Forecast (Daily)', color='purple', linestyle=':')
+        
+        # plt.title(f'{commodity} Price: Actual vs. Predicted & 6-Month Forecast', fontsize=16)
+        # plt.xlabel('Date')
+        # plt.ylabel('Modal Price')
+        # plt.legend()
+        # plt.show()
+        
+        if monthly_forecast_df is not None and not monthly_forecast_df.empty:
+            print(f"\n--- 6-Month Forecast for {commodity} (End of Month Price) ---")
+            print(monthly_forecast_df.to_string(float_format="%.2f"))
+            print("---------------------------------------------------------")
+
+
+    def forecast_six_months(self, commodity, last_known_date):
+        
+        if commodity not in self.models:
+            print(f"❌ Error: Model for {commodity} not found.")
+            return None, None
+
+        model = self.models[commodity]
+        df_commodity = self.df_full[self.df_full['commodity'] == commodity]
+        df_daily = df_commodity.groupby(df_commodity.index).agg({'modal_price': 'mean'})
+        
+        future_dates = pd.date_range(start=last_known_date + pd.Timedelta(days=1), periods=180, freq='D')
+        future_df = pd.DataFrame(index=future_dates, columns=['modal_price'])
+        df_extended = pd.concat([df_daily, future_df])
+        
+        for date in future_dates:
+            featured_row = self._create_features(df_extended.loc[:date]).iloc[-1:]
+            FEATURES = [col for col in featured_row.columns if col != 'modal_price']
+            prediction = model.predict(featured_row[FEATURES])[0]
+            df_extended.loc[date, 'modal_price'] = prediction
+        
+        daily_forecast_df = df_extended.loc[future_dates].copy()
+        daily_forecast_df.rename(columns={'modal_price': 'forecast'}, inplace=True)
+        monthly_forecast_df = daily_forecast_df.resample('ME').last().head(6)
+        return daily_forecast_df, monthly_forecast_df
+
+def train_and_save_models(df):
+    """
+    Trains a model for each commodity and saves it to a .pkl file.
+    """
+    predictor = CommodityPricePredictor(df)
+    commodities = df['commodity'].unique()
+    
+    if not os.path.exists('models'):
+        os.makedirs('models')
+
+    for commodity in commodities:
+        predictor.train(commodity)
+        if commodity in predictor.models:
+            model = predictor.models[commodity]
+            # joblib.dump(model, f'models/{commodity}.pkl')
+            # print(f"✅ Model for {commodity} saved to models/{commodity}.pkl")
+            # # Replace invalid characters for filenames
+            safe_commodity_name = commodity.replace('/', '_') 
+            joblib.dump(model, f'models/{safe_commodity_name}.pkl')
+            print(f"✅ Model for {commodity} saved to models/{safe_commodity_name}.pkl")
+            
+
+if __name__ == '__main__':
+    # Load your dataset here
+    # For example:
+    df_final = pd.read_csv('final_output.csv') 
+    train_and_save_models(df_final)