Upload 12 files

.python-version

@@ -0,0 +1 @@
+3.11

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.9
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,11 +0,0 @@
----
-title: Augosure FastAPI Services
-emoji: 🌍
-colorFrom: red
-colorTo: blue
-sdk: docker
-pinned: false
-short_description: Agrosure FastAPI Services
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

SETUP.md

@@ -0,0 +1,47 @@
+# Python Backend Setup Guide
+
+## Environment Variables Setup
+
+The Python backend requires Cloudinary credentials to be configured. You can set these up in two ways:
+
+### Option 1: Environment Variables
+Set the following environment variables in your system:
+
+```bash
+export CLOUDINARY_CLOUD_NAME=your_cloudinary_cloud_name
+export CLOUDINARY_API_KEY=your_cloudinary_api_key
+export CLOUDINARY_API_SECRET=your_cloudinary_api_secret
+```
+
+### Option 2: .env File
+Create a `.env` file in the `python_backend` directory with the following content:
+
+```
+CLOUDINARY_CLOUD_NAME=your_cloudinary_cloud_name
+CLOUDINARY_API_KEY=your_cloudinary_api_key
+CLOUDINARY_API_SECRET=your_cloudinary_api_secret
+```
+
+Replace `your_cloudinary_cloud_name`, `your_cloudinary_api_key`, and `your_cloudinary_api_secret` with your actual Cloudinary credentials.
+
+## Installation
+
+1. Install the required dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+2. Run the FastAPI server:
+```bash
+python app.py
+```
+
+The server will start on `http://localhost:5000`
+
+## API Endpoints
+
+- `POST /api/exif_metadata` - Extract EXIF metadata from images
+- `POST /api/damage_detection` - Detect crop damage from images
+- `POST /api/crop_type` - Identify crop type from images
+- `POST /predictForCrop` - Predict crop yield
+- `POST /futureWeatherPrediction` - Get weather predictions and claim recommendations 

app.py

@@ -0,0 +1,293 @@
+from fastapi import FastAPI, HTTPException, Query
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+import os
+import requests
+import time
+import cloudinary
+import cloudinary.utils
+import engine
+import config
+import futureWeather
+import warnings
+import re
+from geopy.geocoders import Nominatim
+from geopy.exc import GeocoderTimedOut
+import pandas as pd
+
+# Load environment variables from .env file
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    print("Warning: python-dotenv not installed. Using system environment variables only.")
+
+warnings.filterwarnings("ignore")
+
+app = FastAPI()
+
+# Configure Cloudinary using environment variables
+cloudinary_config = {
+    'cloud_name': config.CLOUDINARY_CLOUD_NAME,
+    'api_key': config.CLOUDINARY_API_KEY,
+    'api_secret': config.CLOUDINARY_API_SECRET
+}
+
+# Validate that all required Cloudinary credentials are present
+if not all(cloudinary_config.values()):
+    print("Warning: Some Cloudinary environment variables are missing!")
+    missing = [k for k, v in cloudinary_config.items() if not v]
+    print(f"Missing: {missing}")
+
+cloudinary.config(**cloudinary_config)
+
+# Ensure upload directory exists
+UPLOAD_FOLDER = 'Uploads'
+if not os.path.exists(UPLOAD_FOLDER):
+    os.makedirs(UPLOAD_FOLDER)
+
+# Pydantic models for request validation
+class ImageRequest(BaseModel):
+    publicId: str
+    fileType: str
+    originalName: str | None = None
+
+class CropYieldRequest(BaseModel):
+    cropName: str
+    locationLat: float
+    locationLong: float
+
+class WeatherPredictionRequest(BaseModel):
+    locationLat: float
+    locationLong: float
+    language: str
+
+# Generate signed URL for Cloudinary
+def get_signed_url(public_id: str, resource_type: str = 'image', expires_in: int = 300) -> str:
+    expires_at = int(time.time()) + expires_in
+    url, options = cloudinary.utils.cloudinary_url(
+        public_id,
+        resource_type=resource_type,
+        type="authenticated",
+        sign_url=True,
+        expires_at=expires_at
+    )
+    return url
+
+# Download from Cloudinary and save to local file
+def download_file(public_id: str, save_path: str, file_type: str = 'image/jpeg') -> bool:
+    resource_type = 'raw' if file_type == 'raw' else 'image'
+    url = get_signed_url(public_id, resource_type=resource_type)
+    response = requests.get(url, headers={'Content-Type': file_type})
+    if response.status_code == 200:
+        with open(save_path, 'wb') as f:
+            f.write(response.content)
+        return True
+    return False
+
+# --- FastAPI Routes ---
+@app.get("/")
+async def root():
+    return {
+        "message": "Agrosure API is running!", 
+        "status": "healthy",
+        "endpoints": {
+            "exif_metadata": "/api/exif_metadata",
+            "damage_detection": "/api/damage_detection", 
+            "crop_type": "/api/crop_type",
+            "crop_yield_prediction": "/predictForCrop",
+            "weather_prediction": "/futureWeatherPrediction"
+        },
+        "docs": "/docs",
+        "redoc": "/redoc"
+    }
+
+@app.post("/api/exif_metadata")
+async def exif_metadata(image_request: ImageRequest):
+    filename = image_request.originalName or f"{image_request.publicId.split('/')[-1]}.jpg"
+    filepath = os.path.join(UPLOAD_FOLDER, filename)
+    
+    if not download_file(image_request.publicId, filepath, image_request.fileType):
+        raise HTTPException(status_code=500, detail=f"Failed to download image from Cloudinary: {image_request.publicId}")
+    
+    result = engine.get_exif_data(filepath)
+    os.remove(filepath)
+    return result
+
+@app.post("/api/damage_detection")
+async def damage_detection(image_request: ImageRequest):
+    print(f"Received damage detection request: {image_request}")
+    filename = image_request.originalName or f"{image_request.publicId.split('/')[-1]}.jpg"
+    filepath = os.path.join(UPLOAD_FOLDER, filename)
+    
+    if not download_file(image_request.publicId, filepath, image_request.fileType):
+        raise HTTPException(status_code=500, detail=f"Failed to download image from Cloudinary: {image_request.publicId}")
+    
+    result = engine.predict_damage(filepath)
+    os.remove(filepath)
+    return result
+
+@app.post("/api/crop_type")
+async def crop_type(image_request: ImageRequest):
+    filename = image_request.originalName or f"{image_request.publicId.split('/')[-1]}.jpg"
+    filepath = os.path.join(UPLOAD_FOLDER, filename)
+    
+    if not download_file(image_request.publicId, filepath, image_request.fileType):
+        raise HTTPException(status_code=500, detail=f"Failed to download image from Cloudinary: {image_request.publicId}")
+    
+    result = engine.predict_crop(filepath)
+    os.remove(filepath)
+    return result
+
+@app.post("/predictForCrop")
+async def predict_crop_yield(data: CropYieldRequest):
+    if not (-90 <= data.locationLat <= 90) or not (-180 <= data.locationLong <= 180):
+        raise HTTPException(status_code=400, detail="Invalid latitude or longitude values")
+
+    try:
+        result = engine.predict_crop_yield_from_location(
+            crop_input=data.cropName.upper(),
+            lat=data.locationLat,
+            lon=data.locationLong
+        )
+        return result
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=f"Invalid numeric input: {str(e)}")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    
+
+@app.post("/futureWeatherPrediction")
+async def future_weather_prediction(data: WeatherPredictionRequest):
+    if not (-90 <= data.locationLat <= 90) or not (-180 <= data.locationLong <= 180):
+        raise HTTPException(status_code=400, detail="Invalid latitude or longitude values")
+
+    try:
+        tom = futureWeather.fetch_tomorrow(data.locationLat, data.locationLong)
+        if not tom or len(tom.get("timelines", {}).get("daily", [])) < 7:
+            weather_data, source = futureWeather.fetch_open_meteo(data.locationLat, data.locationLong), "open-meteo"
+        else:
+            weather_data, source = tom, "tomorrow"
+
+        summary, score, should_claim, flags = futureWeather.extract_and_calc(weather_data, source)
+        ai_text = futureWeather.invoke_gemini(summary, score, should_claim, flags, data.language)
+
+        return {
+            "claim_recommendation": {
+                "should_claim": should_claim,
+                "weather_trend_risk_score": round(score, 2),
+                "forecast_summary": summary,
+                "language": data.language,
+                "gemini_response": ai_text
+            }
+        }
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=f"Invalid numeric input: {str(e)}")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    
+
+
+## MADE BY UDDALAK MUKHERJEE
+# Load and clean crop data once on startup
+CROP_DATA_PATH = "data/ICRISAT-District_Level_Data_30_Years.csv"
+df_crop = pd.read_csv(CROP_DATA_PATH)
+df_crop_clean = df_crop.drop(columns=['State Code', 'Year', 'State Name'], errors='ignore')
+mean_crop_by_district = df_crop_clean.groupby('Dist Name').mean(numeric_only=True)
+
+def get_district_from_coordinates(lat, lon): 
+    geolocator = Nominatim(user_agent="agrisure-ai")
+    try:
+        location = geolocator.reverse((lat, lon), exactly_one=True)
+    except GeocoderTimedOut:
+        raise Exception("Reverse geocoding service timed out.")
+    except Exception as e:
+        raise Exception(f"Geocoding error: {str(e)}")
+    
+    if not location:
+        raise ValueError("Could not get district from coordinates.")
+    
+    # Handle potential async/coroutine response with type ignoring
+    try:
+        # Use type: ignore to suppress type checker warnings for geopy attributes
+        address = location.raw.get('address', {})  # type: ignore
+    except (AttributeError, TypeError):
+        try:
+            # Fallback: try to get address from location attributes
+            addr_str = str(location.address)  # type: ignore
+            # Basic parsing fallback
+            address = {'display_name': addr_str}
+        except (AttributeError, TypeError):
+            raise ValueError("Could not parse location data.")
+    
+    if not address:
+        raise ValueError("Could not get district from coordinates.")
+    district = (
+        address.get('district') or
+        address.get('state_district') or
+        address.get('county')
+    )
+    if district and 'district' in district.lower():
+        district = district.replace("District", "").strip()
+    return district
+
+def clean_district_name(district):
+    if not isinstance(district, str):
+        return district
+    district = re.sub(r"\s*[-\u2013]\s*(I{1,3}|IV|V|VI|VII|VIII|IX|X|\d+)$", "", district, flags=re.IGNORECASE)
+    district = district.replace("District", "").strip()
+    aliases = {
+        "Purba Bardhaman": "Burdwan",
+        "Paschim Bardhaman": "Burdwan",
+        "Bardhaman": "Burdwan",
+        "Kalna": "Burdwan",
+        "Kalyani": "Nadia",
+        "Raiganj": "Uttar Dinajpur",
+        "Kolkata": "North 24 Parganas"
+    }
+    return aliases.get(district, district)
+
+@app.get("/top-crops")
+async def get_top_5_crops(
+    lat: float = Query(..., description="Latitude of the location"),
+    lon: float = Query(..., description="Longitude of the location")
+):
+    try:
+        district_name = get_district_from_coordinates(lat, lon)
+        if not district_name:
+            return JSONResponse(status_code=404, content={"error": "Could not resolve district from coordinates."})
+        
+        district_name = clean_district_name(district_name)
+
+        matched_district = None
+        for dist in mean_crop_by_district.index:
+            if dist.strip().lower() == district_name.lower():
+                matched_district = dist
+                break
+
+        if not matched_district:
+            return JSONResponse(status_code=404, content={"error": f"District '{district_name}' not found in dataset."})
+
+        top_crops = mean_crop_by_district.loc[matched_district].sort_values(ascending=False).head(5)
+        
+        print(top_crops)
+
+        return {
+            "district": matched_district,
+            "top_5_crops": [
+                crop.replace(" (Kg per ha)", "").replace("YIELD", "").strip()
+                for crop in top_crops.index
+            ]
+        }
+
+    except Exception as e:
+        return JSONResponse(status_code=500, content={"error": str(e)})
+
+
+if __name__ == "__main__":
+    import uvicorn
+    print("Starting FastAPI server...")
+    print("Server will be available at:")
+    print("  - http://localhost:5001")
+    print("\nPress CTRL+C to stop the server")
+    uvicorn.run("app:app", host="0.0.0.0", port=5001, reload=True)

config.py

@@ -0,0 +1,6 @@
+CLOUDINARY_CLOUD_NAME="djd6ovzuc"
+CLOUDINARY_API_KEY="661697976329398"
+CLOUDINARY_API_SECRET="rg9GlCFI28GKgHm82WA8bmMnZ5o"
+GEMINI_API_KEY="AIzaSyBwwlfEgmTddBhMmVcNGqhLdpY6Nc7TzMk"
+TOMORROW_API_KEY="uKclyQEYoCJNiqQMHc8wZg7FpVFk76Kl"
+OPENWEATHER_API="dbc4cf80006c9d817da4af9d4578f0fb"

engine.py

@@ -0,0 +1,427 @@
+import os
+from PIL import Image
+import piexif
+import cv2
+import numpy as np
+from geopy.geocoders import Nominatim
+from geopy.exc import GeocoderTimedOut
+import torch
+import timm
+from torchvision import transforms
+import torch.nn.functional as F
+import pandas as pd
+import re
+from prophet import Prophet
+from sklearn.metrics import mean_absolute_error, mean_absolute_percentage_error
+import requests
+import json
+import config
+# Load environment variables from .env file
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    print("Warning: python-dotenv not installed. Using system environment variables only.")
+
+# --- EXIF Metadata Extraction ---
+def get_exif_data(image_path):
+    if not os.path.exists(image_path):
+        return {"error": f"File not found at path {image_path}"}
+
+    suspicious_reasons = []
+    authenticity_score = 100
+
+    try:
+        exif_dict = piexif.load(image_path)
+        gps_info = exif_dict.get('GPS', {})
+
+        def _convert_to_degrees(value):
+            d, m, s = value
+            return d[0]/d[1] + (m[0]/m[1])/60 + (s[0]/s[1])/3600
+
+        lat = lon = None
+        if gps_info:
+            try:
+                lat = round(_convert_to_degrees(gps_info[2]), 6)
+                lon = round(_convert_to_degrees(gps_info[4]), 6)
+                if gps_info[1] == b'S': lat *= -1
+                if gps_info[3] == b'W': lon *= -1
+            except:
+                lat, lon = None, None
+                suspicious_reasons.append("GPS data could not be parsed correctly.")
+        else:
+            suspicious_reasons.append("GPS metadata missing.")
+            authenticity_score -= 30
+
+        address = None
+        if lat and lon:
+            try:
+                geolocator = Nominatim(user_agent="agrisure_exif_reader")
+                location = geolocator.reverse((lat, lon))
+                address = location.address if location else None  # type: ignore
+            except:
+                address = "Geocoder error"
+
+        model = exif_dict['0th'].get(piexif.ImageIFD.Model, b"").decode('utf-8', errors='ignore')
+        timestamp = exif_dict['Exif'].get(piexif.ExifIFD.DateTimeOriginal, b"").decode('utf-8', errors='ignore')
+        software = exif_dict['0th'].get(piexif.ImageIFD.Software, b"").decode('utf-8', errors='ignore')
+
+        if not model:
+            suspicious_reasons.append("Device model missing.")
+            authenticity_score -= 10
+        if not timestamp:
+            suspicious_reasons.append("Timestamp missing.")
+            authenticity_score -= 20
+        if software:
+            suspicious_reasons.append(f"Image was edited using software: {software}")
+            authenticity_score -= 25
+
+        try:
+            ela_path = image_path.replace(".jpg", "_ela.jpg")
+            original = Image.open(image_path).convert('RGB')
+            original.save(ela_path, 'JPEG', quality=90)
+            ela_image = Image.open(ela_path)
+            ela = Image.blend(original, ela_image, alpha=10)
+            ela_cv = np.array(ela)
+            std_dev = np.std(ela_cv)
+            if std_dev > 25:
+                suspicious_reasons.append("High ELA deviation — possible image tampering.")
+                authenticity_score -= 15
+            os.remove(ela_path)
+        except:
+            suspicious_reasons.append("ELA check failed.")
+            authenticity_score -= 5
+
+        return {
+            "verifier": "exif_metadata_reader",
+            "device_model": model or "N/A",
+            "timestamp": timestamp or "N/A",
+            "gps_latitude": lat,
+            "gps_longitude": lon,
+            "address": address,
+            "authenticity_score": max(0, authenticity_score),
+            "suspicious_reasons": suspicious_reasons or ["None"]
+        }
+    except Exception as e:
+        return {"error": f"Failed to analyze image: {str(e)}"}
+
+# --- Crop Damage Detection ---
+device = "cuda" if torch.cuda.is_available() else "cpu"
+val_transform = transforms.Compose([
+    transforms.Resize((384, 384)),
+    transforms.ToTensor(),
+    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+])
+model_damage = timm.create_model('efficientnetv2_rw_m', pretrained=False, num_classes=2)
+model_damage.load_state_dict(torch.load("models/efficientnetv2_rw_m_crop_damage.pt", map_location=device))
+model_damage.to(device)
+model_damage.eval()
+class_names = ['damaged', 'non_damaged']
+
+def predict_damage(image_path):
+    if not os.path.exists(image_path):
+        return {"status": "error", "message": f"File not found: {image_path}"}
+
+    try:
+        image = Image.open(image_path).convert('RGB')
+        input_tensor = val_transform(image).unsqueeze(0).to(device)
+        with torch.no_grad():
+            output = model_damage(input_tensor)
+            probs = torch.softmax(output, dim=1)
+            predicted_class = int(torch.argmax(probs, dim=1).item())
+            confidence = float(probs[0][predicted_class].item())
+        predicted_label = class_names[predicted_class]
+        return {
+            "verifier": "crop_damage_classifier",
+            "model": "efficientnetv2_rw_m",
+            "prediction": predicted_label,
+            "confidence": round(confidence * 100, 2),
+            "class_names": class_names,
+            "status": "success"
+        }
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+# --- Crop Type Detection ---
+val_transforms_crop = transforms.Compose([
+    transforms.Resize((224, 224)),
+    transforms.ToTensor(),
+    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
+])
+idx_to_class = {
+    0: 'Coffee-plant', 1: 'Cucumber', 2: 'Fox_nut(Makhana)', 3: 'Lemon', 4: 'Olive-tree',
+    5: 'Pearl_millet(bajra)', 6: 'Tobacco-plant', 7: 'almond', 8: 'banana', 9: 'cardamom',
+    10: 'cherry', 11: 'chilli', 12: 'clove', 13: 'coconut', 14: 'cotton', 15: 'gram',
+    16: 'jowar', 17: 'jute', 18: 'maize', 19: 'mustard-oil', 20: 'papaya', 21: 'pineapple',
+    22: 'rice', 23: 'soyabean', 24: 'sugarcane', 25: 'sunflower', 26: 'tea', 27: 'tomato',
+    28: 'vigna-radiati(Mung)', 29: 'wheat'
+}
+model_crop = timm.create_model('convnext_tiny', pretrained=False, num_classes=30)
+model_crop.load_state_dict(torch.load('models/crop_type_detection_model.pth', map_location=device))
+model_crop.to(device)
+model_crop.eval()
+
+def predict_crop(image_path):
+    if not os.path.exists(image_path):
+        return {"status": "error", "message": f"File not found: {image_path}"}
+
+    try:
+        image = Image.open(image_path).convert('RGB')
+        image_tensor = val_transforms_crop(image).unsqueeze(0).to(device)
+        with torch.no_grad():
+            outputs = model_crop(image_tensor)
+            probs = F.softmax(outputs, dim=1)
+            conf, pred = torch.max(probs, 1)
+            predicted_label = idx_to_class[pred.item()]
+            confidence = round(float(conf.item()) * 100, 2)
+        return {
+            "status": "success",
+            "predicted_class": predicted_label,
+            "confidence_percent": confidence
+        }
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+# --- Crop Yield Prediction Utilities ---
+def get_district_from_coordinates(lat, lon):
+    geolocator = Nominatim(user_agent="agrisure-ai")
+    try:
+        location = geolocator.reverse((lat, lon))
+    except GeocoderTimedOut:
+        return None, None, "Reverse geocoding service timed out."
+    except Exception as e:
+        return None, None, f"Geocoding error: {str(e)}"
+    
+    if not location:
+        return None, None, "Could not get district from coordinates."
+    
+    try:
+        address = location.raw.get('address', {})  # type: ignore
+    except (AttributeError, TypeError):
+        return None, None, "Could not parse location data."
+    
+    if not address:
+        return None, None, "Could not get district from coordinates."
+    district = (
+        address.get('district') or
+        address.get('state_district') or
+        address.get('county')
+    )
+    if not district:
+        return None, None, "District not found in address data."
+    if 'district' in district.lower():
+        district = district.replace("District", "").strip()
+    place_name = district  # Set place_name to district name
+    return district, place_name, None
+
+def clean_district_name(district):
+    if not isinstance(district, str):
+        return district
+    district = re.sub(r"\s*[-\u2013]\s*(I{1,3}|IV|V|VI|VII|VIII|IX|X|\d+)$", "", district, flags=re.IGNORECASE)
+    district = district.replace("District", "").strip()
+    aliases = {
+        "Purba Bardhaman": "Burdwan",
+        "Paschim Bardhaman": "Burdwan",
+        "Bardhaman": "Burdwan",
+        "Kalna": "Burdwan",
+        "Kalyani": "Nadia",
+        "Raiganj": "Uttar Dinajpur",
+        "Kolkata": "North 24 Parganas"
+    }
+    return aliases.get(district, district)
+
+def get_soil_category(score):
+    if score == 0:
+        return "No Soil Health Data"
+    elif score >= 4.5:
+        return "Very Excellent Soil Health"
+    elif score >= 4:
+        return "Excellent Soil Health"
+    elif score >= 3:
+        return "Good Soil Health"
+    elif score >= 2:
+        return "Poor Soil Health"
+    else:
+        return "Very Poor Soil Health"
+
+def calculate_dynamic_climate_score(predicted_yield, soil_score, max_yield=8000, max_soil=5.0):
+    norm_yield = (predicted_yield / max_yield) ** 0.8
+    norm_soil = (soil_score / max_soil) ** 1.2
+    return round((0.6 * norm_yield + 0.4 * norm_soil) * 100, 2)
+
+def forecast_yield(ts_data):
+    model = Prophet(yearly_seasonality='auto', growth='flat')
+    model.fit(ts_data)
+    forecast = model.predict(model.make_future_dataframe(periods=1, freq='YS'))
+    return max(forecast.iloc[-1]['yhat'], 0)
+
+def forecast_yield_with_accuracy(ts_data):
+    model = Prophet(yearly_seasonality='auto', growth='flat')
+    model.fit(ts_data)
+    future = model.make_future_dataframe(periods=1, freq='YS')
+    forecast = model.predict(future)
+    predicted_yield = max(forecast.iloc[-1]['yhat'], 0)
+
+    try:
+        past = forecast[forecast['ds'] < ts_data['ds'].max()]
+        merged = ts_data.merge(past[['ds', 'yhat']], on='ds')
+        mae = mean_absolute_error(merged['y'], merged['yhat'])
+        mape = mean_absolute_percentage_error(merged['y'], merged['yhat']) * 100
+    except:
+        mae, mape = None, None
+
+    return predicted_yield, mae, mape
+
+def get_crop_priority_list(district_yield, base_crop_names):
+    priority_list = []
+    for crop, column in base_crop_names.items():
+        crop_data = district_yield[['Year', column]].dropna()
+        crop_data.columns = ['ds', 'y']
+        crop_data['ds'] = pd.to_datetime(crop_data['ds'], format='%Y')
+        if len(crop_data) >= 5:
+            yield_pred = forecast_yield(crop_data)
+            priority_list.append((crop, yield_pred))
+    return sorted(priority_list, key=lambda x: x[1], reverse=True)
+
+def get_weather_data(lat, lon):
+    try:
+        # Get weather API key from environment variables
+        weather_api_key = config.OPENWEATHER_API
+        if weather_api_key and weather_api_key != "your_openweather_api_key_here":
+            url = f"https://api.weatherapi.com/v1/current.json?key={weather_api_key}&q={lat},{lon}"
+            response = requests.get(url)
+            data = response.json()
+            return {
+                "temp_c": data['current']['temp_c'],
+                "humidity": data['current']['humidity'],
+                "condition": data['current']['condition']['text'],
+                "wind_kph": data['current']['wind_kph']
+            }
+        else:
+            return {"error": "Weather API key not configured or placeholder value"}
+    except Exception as e:
+        return {"error": "Weather fetch failed", "details": str(e)}
+
+def predict_crop_yield_from_location(crop_input, lat, lon):
+    district, place_name, error = get_district_from_coordinates(lat, lon)
+    if error:
+        return {"error": error}
+    
+    if district is None:
+        return {"error": "Could not determine district from coordinates"}
+    
+    district_input = clean_district_name(district)
+
+    try:
+        yield_df = pd.read_csv(r"data\ICRISAT-District_Level_Data_30_Years.csv")
+        soil_df = pd.read_csv(r"data\SoilHealthScores_by_District_2.csv")
+    except Exception as e:
+        return {"error": f"Failed to read data files: {str(e)}"}
+
+    soil_df['Soil_Category'] = soil_df['SoilHealthScore'].apply(get_soil_category)
+    yield_columns = [col for col in yield_df.columns if 'YIELD (Kg per ha)' in col]
+    base_crop_names = {col.split(' YIELD')[0]: col for col in yield_columns}
+
+    if crop_input not in base_crop_names:
+        return {"error": f"'{crop_input}' not found in crop list."}
+
+    yield_col = base_crop_names[crop_input]
+    
+    # Ensure district_input is not None before using lower()
+    if district_input is None:
+        return {"error": "Could not determine district name"}
+    
+    district_yield = yield_df[yield_df['Dist Name'].str.lower() == district_input.lower()]
+    district_soil = soil_df[soil_df['Dist Name'].str.lower() == district_input.lower()]
+
+    if district_yield.empty or district_soil.empty:
+        return {"error": f"Data for district '{district_input}' not found."}
+
+    ts_data = district_yield[['Year', yield_col]].dropna()
+    ts_data.columns = ['ds', 'y']
+    ts_data['ds'] = pd.to_datetime(ts_data['ds'], format='%Y')
+    ts_data['year'] = ts_data['ds'].dt.year
+
+    valid_data = ts_data[ts_data['y'] > 0]
+    if len(valid_data) < 6:
+        predicted_yield = ts_data['y'].mean()
+        mae, mape = None, None
+    else:
+        predicted_yield, mae, mape = forecast_yield_with_accuracy(valid_data)
+
+    if predicted_yield > 1000:
+        yield_cat = "Highly Recommended Crop"
+    elif predicted_yield > 500:
+        yield_cat = "Good Crop"
+    elif predicted_yield > 200:
+        yield_cat = "Poor Crop"
+    else:
+        yield_cat = "Very Poor Crop"
+
+    soil_score = district_soil['SoilHealthScore'].values[0]
+    soil_cat = district_soil['Soil_Category'].values[0]
+    climate_score = calculate_dynamic_climate_score(predicted_yield, soil_score)
+
+    sorted_crops = get_crop_priority_list(district_yield, base_crop_names)
+    best_crop = sorted_crops[0][0] if sorted_crops else None
+    best_yield = sorted_crops[0][1] if sorted_crops else None
+
+    weather_data = get_weather_data(lat, lon)
+
+    crop_priority_list = []
+    for c, y in sorted_crops:
+        if y > 1000:
+            yc = "Highly Recommended Crop"
+        elif y > 500:
+            yc = "Good Crop"
+        elif y > 200:
+            yc = "Poor Crop"
+        else:
+            yc = "Very Poor Crop"
+
+        score = calculate_dynamic_climate_score(y, soil_score)
+
+        crop_priority_list.append({
+            "crop": c,
+            "predicted_yield": {
+                "kg_per_ha": round(y, 2),
+                "kg_per_acre": round(y / 2.47105, 2)
+            },
+            "yield_category": yc,
+            "climate_score": score
+        })
+
+    return {
+        "location": {
+            "input_coordinates": {"lat": lat, "lon": lon},
+            "place_name": place_name,
+            "detected_district": district,
+        },
+        "input_crop_analysis": {
+            "crop": crop_input,
+            "predicted_yield": {
+                "kg_per_ha": round(predicted_yield, 2),
+                "kg_per_acre": round(predicted_yield / 2.47105, 2)
+            },
+            "yield_category": yield_cat,
+            "prediction_accuracy": {
+                "mae": round(mae, 2) if mae is not None else "Not enough data",
+                "mape_percent": round(mape, 2) if mape is not None else "Not enough data",
+                "accuracy_score": round(100 - mape, 2) if mape is not None else "Not enough data"
+            }
+        },
+        "soil_health": {
+            "score": soil_score,
+            "category": soil_cat
+        },
+        "climate_score": climate_score,
+        "weather_now": weather_data,
+        "best_crop": {
+            "name": best_crop,
+            "predicted_yield": {
+                "kg_per_ha": round(best_yield, 2) if best_crop and best_yield is not None else None,
+                "kg_per_acre": round(best_yield / 2.47105, 2) if best_crop and best_yield is not None else None,
+            }
+        },
+        "crop_priority_list": crop_priority_list
+    }

futureWeather.py

@@ -0,0 +1,231 @@
+
+import requests
+import json
+import numpy as np
+import os
+
+# Load environment variables from .env file
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    print("Warning: python-dotenv not installed. Using system environment variables only.")
+
+try:
+    import google.generativeai as genai
+    GENAI_AVAILABLE = True
+except ImportError:
+    print("Warning: google.generativeai not available")
+    genai = None
+    GENAI_AVAILABLE = False
+
+# --- CONFIG ---
+TOMORROW_API_KEY = os.getenv('TOMORROW_API_KEY')
+GEMINI_API_KEY = os.getenv('GEMINI_API_KEY')
+
+# Configure Gemini AI if available
+if GENAI_AVAILABLE and genai and GEMINI_API_KEY:
+    try:
+        genai.configure(api_key=GEMINI_API_KEY)  # type: ignore
+    except Exception as e:
+        print(f"Warning: Failed to configure Gemini AI: {e}")
+        GENAI_AVAILABLE = False
+
+# --- Ideal Ranges ---
+ideal_ranges = {
+    "rain": {"ideal_min": 10, "ideal_max": 100},
+    "temperature": {"ideal_min": 20, "ideal_max": 35},
+    "humidity": {"ideal_min": 40, "ideal_max": 80},
+    "wind": {"ideal_min": 0, "ideal_max": 20}
+}
+
+# --- Weather Risk Weights ---
+weather_factors = {
+    "rain_risk": {"weight": 0.4, "value": 0},
+    "heat_risk": {"weight": 0.3, "value": 0},
+    "humidity_risk": {"weight": 0.2, "value": 0},
+    "wind_risk": {"weight": 0.1, "value": 0}
+}
+
+# --- Normalize Risk ---
+def normalized_risk(actual, ideal_min, ideal_max):
+    if ideal_min <= actual <= ideal_max:
+        return 0
+    return min(1.0, abs(actual - (ideal_min if actual < ideal_min else ideal_max)) / (ideal_min if actual < ideal_min else ideal_max))
+
+# --- Localize Flags ---
+def localize_flags(flags, lang):
+    translations = {
+        "Unusual rainfall": {
+            "Bengali": "Rainfall is unusually high or low",
+            "Hindi": "Rainfall is unusually high or low",
+            "English": "Rainfall is unusually high or low"
+        },
+        "Heat stress": {
+            "Bengali": "High temperatures may cause crop stress",
+            "Hindi": "High temperatures may cause crop stress",
+            "English": "High temperatures may cause crop stress"
+        },
+        "High humidity": {
+            "Bengali": "High humidity may cause fungal diseases",
+            "Hindi": "High humidity may cause fungal diseases",
+            "English": "High humidity may cause fungal diseases"
+        },
+        "High wind": {
+            "Bengali": "Strong winds may damage crops",
+            "Hindi": "Strong winds may damage crops",
+            "English": "Strong winds may damage crops"
+        }
+    }
+    # Filter out None values and ensure all returned values are strings
+    result = []
+    for f in flags:
+        if f is not None:
+            translated = translations.get(f, {}).get(lang, f)
+            if translated is not None:
+                result.append(str(translated))
+    return result
+
+# --- API Fetches ---
+def fetch_tomorrow(lat, lon):
+    if not TOMORROW_API_KEY:
+        print("Warning: TOMORROW_API_KEY not found in environment variables")
+        return None
+    
+    try:
+        url = f"https://api.tomorrow.io/v4/weather/forecast?location={lat},{lon}&timesteps=1d&apikey={TOMORROW_API_KEY}"
+        r = requests.get(url, timeout=10)
+        return r.json() if r.status_code == 200 else None
+    except Exception as e:
+        print(f"Error fetching Tomorrow.io data: {e}")
+        return None
+
+def fetch_open_meteo(lat, lon):
+    try:
+        url = (
+            f"https://api.open-meteo.com/v1/forecast?"
+            f"latitude={lat}&longitude={lon}"
+            f"&daily=temperature_2m_max,temperature_2m_mean,precipitation_sum,relative_humidity_2m_mean,wind_speed_10m_mean"
+            f"&forecast_days=16&timezone=auto"
+        )
+        response = requests.get(url, timeout=10)
+        return response.json() if response.status_code == 200 else None
+    except Exception as e:
+        print(f"Error fetching Open-Meteo data: {e}")
+        return None
+
+# --- Weather Trend Analysis ---
+def extract_and_calc(data, source):
+    try:
+        if source == "tomorrow":
+            if not data or "timelines" not in data or "daily" not in data["timelines"]:
+                raise ValueError("Invalid Tomorrow.io data structure")
+            arr = data["timelines"]["daily"]
+            days = len(arr)
+            rain = [v["values"].get("precipitationSum", 0) for v in arr]
+            temp_avg = [v["values"].get("temperatureAvg", 0) for v in arr]
+            temp_max = [v["values"].get("temperatureMax", 0) for v in arr]
+            humidity = [v["values"].get("humidityAvg", 0) for v in arr]
+            wind = [v["values"].get("windSpeedAvg", 0) for v in arr]
+        else:  # open-meteo
+            if not data or "daily" not in data:
+                raise ValueError("Invalid Open-Meteo data structure")
+            d = data["daily"]
+            days = len(d["time"])
+            rain = d.get("precipitation_sum", [0] * days)
+            temp_avg = d.get("temperature_2m_mean", [0] * days)
+            temp_max = d.get("temperature_2m_max", [0] * days)
+            humidity = d.get("relative_humidity_2m_mean", [0] * days)
+            wind = d.get("wind_speed_10m_mean", [0] * days)
+
+        # Handle potential None values in arrays
+        rain = [r if r is not None else 0 for r in rain]
+        temp_avg = [t if t is not None else 0 for t in temp_avg]
+        temp_max = [t if t is not None else 0 for t in temp_max]
+        humidity = [h if h is not None else 0 for h in humidity]
+        wind = [w if w is not None else 0 for w in wind]
+
+        total_rain = float(np.sum(rain))
+        avg_temp = float(np.mean(temp_avg))
+        max_temp = float(np.max(temp_max))
+        avg_humidity = float(np.mean(humidity))
+        avg_wind = float(np.mean(wind))
+        dry_days = int(sum(1 for r in rain if r < 1))
+    except Exception as e:
+        print(f"Error processing weather data: {e}")
+        # Return default values in case of error
+        return {
+            "avg_temp_c": 25.0,
+            "max_temp_c": 30.0,
+            "total_rainfall_mm": 50.0,
+            "dry_days": 3,
+            "avg_humidity_percent": 60.0,
+            "avg_wind_speed_kmph": 10.0,
+            "forecast_days_used": 7,
+            "source": source,
+            "error": str(e)
+        }, 0.3, False, []
+
+    weather_factors["rain_risk"]["value"] = normalized_risk(total_rain, **ideal_ranges["rain"])
+    weather_factors["heat_risk"]["value"] = normalized_risk(avg_temp, **ideal_ranges["temperature"])
+    weather_factors["humidity_risk"]["value"] = normalized_risk(avg_humidity, **ideal_ranges["humidity"])
+    weather_factors["wind_risk"]["value"] = normalized_risk(avg_wind, **ideal_ranges["wind"])
+
+    risk_score = float(sum(f["value"] * f["weight"] for f in weather_factors.values()))
+    should_claim = bool(risk_score >= 0.5)
+
+    flags = []
+    if weather_factors["rain_risk"]["value"] > 0.3:
+        flags.append("Unusual rainfall")
+    if weather_factors["heat_risk"]["value"] > 0.3:
+        flags.append("Heat stress")
+    if weather_factors["humidity_risk"]["value"] > 0.3:
+        flags.append("High humidity")
+    if weather_factors["wind_risk"]["value"] > 0.3:
+        flags.append("High wind")
+
+    summary = {
+        "avg_temp_c": round(avg_temp, 2),
+        "max_temp_c": round(max_temp, 2),
+        "total_rainfall_mm": round(total_rain, 2),
+        "dry_days": dry_days,
+        "avg_humidity_percent": round(avg_humidity, 2),
+        "avg_wind_speed_kmph": round(avg_wind, 2),
+        "forecast_days_used": days,
+        "source": source
+    }
+
+    return summary, risk_score, should_claim, flags
+
+# --- Gemini AI Interpretation ---
+def invoke_gemini(summary, score, should_claim, flags, lang):
+    if not GENAI_AVAILABLE or not genai:
+        return f"AI service unavailable. Based on weather analysis: {'Claim recommended' if should_claim else 'No claim needed'}"
+    
+    localized_flags = localize_flags(flags, lang)
+    prompt = f"""
+You are a crop insurance assistant. Respond ONLY in {lang}.
+
+Weather Summary:
+- Total Rainfall: {summary['total_rainfall_mm']} mm
+- Avg Temperature: {summary['avg_temp_c']} °C
+- Max Temperature: {summary['max_temp_c']} °C
+- Avg Humidity: {summary['avg_humidity_percent']} %
+- Avg Wind Speed: {summary['avg_wind_speed_kmph']} km/h
+- Dry Days: {summary['dry_days']} days
+
+Risks Observed:
+- {'; '.join(localized_flags) if localized_flags else 'No major weather risks observed.'}
+
+Final Output:
+- Bullet points for why claim is or is not needed.
+- A brief interpretation about whether to claim crop insurance or not.
+"""
+    
+    try:
+        model = genai.GenerativeModel("gemini-2.0-flash")  # type: ignore
+        response = model.generate_content(prompt)
+        return response.text.strip()
+    except Exception as e:
+        print(f"Error calling Gemini AI: {e}")
+        return f"AI service error. Based on weather analysis: {'Claim recommended' if should_claim else 'No claim needed'}"

pyproject.toml

@@ -0,0 +1,28 @@
+[project]
+name = "python-backend"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "cloudinary>=1.44.1",
+    "cupy-cuda102>=12.3.0",
+    "fastapi>=0.116.0",
+    "flask==2.2.5",
+    "geopy==2.4.1",
+    "google-generativeai>=0.8.5",
+    "numpy==1.24.3",
+    "ollama>=0.5.1",
+    "opencv-python==4.8.0.76",
+    "pandas",
+    "piexif==1.1.3",
+    "pillow==9.5.0",
+    "plotly>=6.2.0",
+    "prophet>=1.1.7",
+    "python-dotenv>=1.1.1",
+    "scikit-learn>=1.7.0",
+    "sentence-transformers>=4.1.0",
+    "timm==0.9.2",
+    "torch==2.0.1",
+    "uvicorn>=0.35.0",
+]

requirements.txt

@@ -0,0 +1,20 @@
+cloudinary==1.44.1
+fastapi==0.116.1
+geopy==2.3.0
+numpy==2.3.2
+opencv_contrib_python==4.10.0.84
+opencv_python==4.10.0.84
+opencv_python_headless==4.10.0.84
+pandas==2.3.1
+piexif==1.1.3
+Pillow==11.3.0
+prophet==1.1.6
+protobuf==6.31.1
+pydantic==2.11.7
+python-dotenv==1.1.1
+Requests==2.32.4
+scikit_learn==1.7.1
+timm==1.0.19
+torch==2.7.1+cu128
+torchvision==0.22.1+cu128
+uvicorn==0.35.0

setup.bat

@@ -0,0 +1,2 @@
+uv add -r requirements.txt
+uv run app.py