app.py

from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import JSONResponse
from pydantic import BaseModel
from typing import Optional
import re

# ----------------- FastAPI App -----------------
app = FastAPI(title="Maharashtra Schemes API")

# Add CORS middleware - THIS IS IMPORTANT
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # Allow all origins
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# ----------------- Data Storage -----------------
SCHEMES_DATA = []

# ----------------- Load Data from prompt.txt -----------------
def load_schemes_data():
    """Parse the prompt.txt file and load all schemes"""
    schemes = []
    
    # Using the data from your document
    schemes_text = """
Question 1
question: पीएम किसान योजनेअंतर्गत किती रुपये मिळतात?
scheme_name: प्रधानमंत्री किसान सन्मान निधी
link: https://www.myscheme.gov.in/schemes/pm-kisan
eligibility: ज्यांच्या नावावर शेतीयोग्य जमीन आहे असे सर्व जमीनधारक शेतकरी कुटुंब या योजनेस पात्र आहेत.
benefits: प्रति वर्षी प्रति कुटुंब 6000 रुपयांची आर्थिक मदत. ही मदत प्रत्येक चार महिन्यांनी 2000 रुपयांच्या तीन समान हप्त्यांमध्ये दिली जाते.
description: या योजनेचा उद्देश जमीनधारक शेतकरी कुटुंबांची आर्थिक गरज भागवून योग्य पिकउत्पादन व योग्य उत्पन्न मिळण्यास मदत करणे हा आहे. केंद्र सरकार थेट लाभ हस्तांतरण (Direct Benefit Transfer) प्रणालीने पात्र शेतकऱ्यांच्या बँक खात्यात रक्कम जमा करते.
Question 2
question: माझे वार्षिक उत्पन्न ₹१.५ लाखांपेक्षा कमी आहे; तर मला कोणत्या सरकारी योजना मिळू शकतात?
scheme_name: महाराष्ट्र अनुसूचित जाती/नव-बौद्ध शेतकरी विहीर अनुदान योजना
link: https://mahadbt.maharashtra.gov.in/Farmer/SchemeData/SchemeData?str=E9DDFA703C38E51A986837A04E50D9EF
eligibility: शेतकरी महाराष्ट्र राज्यातील अनुसूचित जाती (SC) किंवा नव-बौद्ध असावा. वार्षिक उत्पन्न 1.5 लाखांपेक्षा कमी असावे. जमीन 0.40 ते 6 हेक्टर दरम्यान असावी.
benefits: नवीन विहीर खोदण्यासाठी 2.5 लाख रुपये पर्यंत 100% अनुदान मिळते. तसेच जुन्या विहिरींच्या दुरुस्तीसाठी, पंप सेट, वीजजोडणी आणि मायक्रो-इरिगेशन प्रणालीसाठी मदत उपलब्ध होते.
description: ही महाराष्ट्र शासनाची सिंचन संबंधित योजना असून SC आणि नव-बौद्ध शेतकऱ्यांना शाश्वत सिंचनस्रोत उपलब्ध करून आर्थिक स्वावलंबन मिळविण्यासाठी सुरू करण्यात आली आहे.
Question 3
question: सोन्यावर कर्ज घेऊन शेतीचे काम करता येते का?
scheme_name: कृषी सुवर्ण कर्ज योजना
link: https://www.myscheme.gov.in/schemes/gold-loan
eligibility: सोन्याचे दागिने असणारे आणि बँकेच्या KYC व जमीनसंबंधित नियमांचे पालन करणारे शेतकरी या योजनेत कर्ज घेऊ शकतात.
benefits: बियाणे, खते, मजुरी, सिंचन इत्यादी शेतीसाठी लागणाऱ्या कामांसाठी सोन्यावर कमी व्याजदरात तात्काळ कर्ज मिळते.
description: या योजनेद्वारे शेतकरी सोन्याचे दागिने तारण ठेवून अल्पकालीन कर्ज घेऊ शकतात. कर्जाची रक्कम सोन्याचे वजन व शुद्धतेनुसार ठरते आणि कर्जाची परतफेड पिकाचे उत्पन्न मिळाल्यानंतर किंवा ठरविलेल्या कालावधीत करता येते.
Question 4
question: शेतीसाठी नवीन यंत्र खरेदी करायचे आहेत, सबसिडी मिळते का?
scheme_name: कृषी यंत्रीकरण अंतर्गत उप-अभियान (SMAM)
link: https://www.myscheme.gov.in/schemes/smam
eligibility: योजना मार्गदर्शक तत्त्वांनुसार अधिकृत विक्रेत्याकडून यंत्र खरेदी करणारे सर्व शेतकरी, लहान व सीमांत तसेच महिला शेतकरी सुद्धा पात्र आहेत.
benefits: ट्रॅक्टर, पॉवर टिलर, स्प्रेयर्स, हार्वेस्टर आणि विविध आधुनिक कृषी यंत्रांवर आर्थिक अनुदान मिळते, ज्यामुळे मजुरी खर्च कमी होतो आणि शेतीचे उत्पादन वाढते.
description: या योजनेचा उद्देश शेतीकरिता आधुनिक यंत्रांचा वापर वाढवणे, शेती सुलभ करणे आणि उत्पन्न वाढवणे हा आहे. अर्ज राज्य कृषी विभागामार्फत करता येतो आणि अनुदानित दरात यंत्रे उपलब्ध होतात.
Question 5
question: पीएम फसल विमा योजनेत पिकाचे नुकसान झाल्यास किती मदत मिळते?
scheme_name: प्रधानमंत्री फसल बीमा योजना (PMFBY)
link: https://www.myscheme.gov.in/schemes/pmfby
eligibility: अधिसूचित पिके आणि अधिसूचित क्षेत्रातील सर्व शेतकरी, कर्जदार असो किंवा नॉन-कर्जदार, या योजनेसाठी पात्र आहेत.
benefits: दुष्काळ, पूर, गारपीट, चक्रीवादळ, कीड, रोग यांसारख्या नैसर्गिक आपत्तीमुळे झालेल्या पिकनुकसानीवर विमा संरक्षण मिळते. शेतकऱ्यांना फक्त खरीपासाठी 2% प्रीमियम, रबीसाठी 1.5% आणि व्यावसायिक पिकांसाठी 5% प्रीमियम भरावा लागतो.
description: या योजनेद्वारे शेतकऱ्यांचे पिक नष्ट झाल्यास त्यांना आर्थिक मदत मिळते, ज्यामुळे कर्जबाजारी होण्याची वेळ येत नाही आणि शेती सलग सुरू ठेवता येते. शेतकऱ्यांनी भरलेल्या प्रीमियमच्या उर्वरित रकमेची भर केंद्र आणि राज्य सरकार करते.
"""
    
    # Parse the text into structured data
    current_scheme = {}
    
    for line in schemes_text.strip().split('\n'):
        line = line.strip()
        if not line or line.startswith('Question'):
            if current_scheme and len(current_scheme) >= 5:
                schemes.append(current_scheme)
            current_scheme = {}
            continue
            
        if ':' in line:
            key, value = line.split(':', 1)
            current_scheme[key.strip()] = value.strip()
    
    # Add the last scheme
    if current_scheme and len(current_scheme) >= 5:
        schemes.append(current_scheme)
    
    return schemes

# ----------------- Helper Functions -----------------
def normalize_text(text: str) -> str:
    """Normalize text for comparison - remove extra spaces, lowercase"""
    text = text.lower().strip()
    text = re.sub(r'\s+', ' ', text)  # Replace multiple spaces with single space
    return text

def find_matching_scheme(user_question: str) -> Optional[dict]:
    """Find a scheme that matches the user's question"""
    normalized_query = normalize_text(user_question)
    
    # First try exact match
    for scheme in SCHEMES_DATA:
        if normalize_text(scheme['question']) == normalized_query:
            return scheme
    
    # Then try partial match - check if user query is contained in any question
    for scheme in SCHEMES_DATA:
        if normalized_query in normalize_text(scheme['question']) or \
           normalize_text(scheme['question']) in normalized_query:
            return scheme
    
    # Check for keyword matches
    for scheme in SCHEMES_DATA:
        question_words = set(normalize_text(scheme['question']).split())
        query_words = set(normalized_query.split())
        
        # If 50% or more words match, consider it a match
        common_words = question_words.intersection(query_words)
        if len(common_words) >= len(query_words) * 0.5:
            return scheme
    
    return None

# ----------------- Request / Response Models -----------------
class QueryRequest(BaseModel):
    question: str

class SchemeResponse(BaseModel):
    found: bool
    scheme_name: Optional[str] = None
    link: Optional[str] = None
    eligibility: Optional[str] = None
    benefits: Optional[str] = None
    description: Optional[str] = None
    formatted_answer: Optional[str] = None

# ----------------- API Endpoints -----------------
@app.on_event("startup")
async def startup_event():
    """Load data when server starts"""
    global SCHEMES_DATA
    SCHEMES_DATA = load_schemes_data()
    print(f"✅ Loaded {len(SCHEMES_DATA)} schemes successfully!")

@app.get("/")
def root():
    """Root endpoint - returns JSON"""
    return JSONResponse(
        content={
            "message": "Maharashtra Schemes API is running!",
            "total_schemes": len(SCHEMES_DATA),
            "endpoints": {
                "/query": "POST - Search for a scheme",
                "/schemes": "GET - List all available schemes"
            }
        }
    )

@app.post("/query")
def query_scheme(request: QueryRequest):
    """Search for a scheme based on user question - returns JSON"""
    try:
        matched_scheme = find_matching_scheme(request.question)
        
        if not matched_scheme:
            return JSONResponse(
                content={
                    "found": False,
                    "scheme_name": None,
                    "link": None,
                    "eligibility": None,
                    "benefits": None,
                    "description": None,
                    "formatted_answer": "माफ करा, तुमच्या प्रश्नाशी जुळणारी कोणतीही योजना सापडली नाही. कृपया प्रश्न वेगळ्या पद्धतीने विचारा."
                }
            )
        
        # Format the response in Marathi
        formatted_answer = (
            f"✅ योजना सापडली!\n\n"
            f"📋 योजनेचे नाव: {matched_scheme['scheme_name']}\n\n"
            f"🔗 अर्जासाठी लिंक: {matched_scheme['link']}\n\n"
            f"📝 वर्णन:\n{matched_scheme['description']}\n\n"
            f"👥 पात्रता:\n{matched_scheme['eligibility']}\n\n"
            f"💰 लाभ:\n{matched_scheme['benefits']}"
        )
        
        return JSONResponse(
            content={
                "found": True,
                "scheme_name": matched_scheme['scheme_name'],
                "link": matched_scheme['link'],
                "eligibility": matched_scheme['eligibility'],
                "benefits": matched_scheme['benefits'],
                "description": matched_scheme['description'],
                "formatted_answer": formatted_answer
            }
        )
    except Exception as e:
        return JSONResponse(
            status_code=500,
            content={
                "found": False,
                "error": str(e),
                "formatted_answer": "त्रुटी आली. कृपया पुन्हा प्रयत्न करा."
            }
        )

@app.get("/schemes")
def list_all_schemes():
    """List all available schemes - returns JSON"""
    return JSONResponse(
        content={
            "total_schemes": len(SCHEMES_DATA),
            "schemes": [
                {
                    "question": scheme['question'],
                    "scheme_name": scheme['scheme_name']
                }
                for scheme in SCHEMES_DATA
            ]
        }
    )

# Global exception handler to ensure JSON responses
@app.exception_handler(Exception)
async def global_exception_handler(request, exc):
    return JSONResponse(
        status_code=500,
        content={
            "error": "Internal server error",
            "detail": str(exc)
        }
    )

# ----------------- Run Server -----------------
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=7860)  # Hugging Face uses port 7860