Update engine.py

engine.py

@@ -1,427 +1,428 @@
-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
-    }
+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:
+        data_dir = "data"
+        yield_df = pd.read_csv(os.path.join(data_dir, "ICRISAT-District_Level_Data_30_Years.csv"))
+        soil_df = pd.read_csv(os.path.join(data_dir, "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
+    }