Update app.py

app.py

@@ -1,524 +1,434 @@
+# app.py
 import os
-from flask import Flask, render_template, request, jsonify
+from flask import Flask, render_template, request, jsonify, redirect, url_for, flash, session
 import requests
-import pandas as pd
-from datetime import datetime
-import plotly.express as px
-import plotly.io as pio
-from googletrans import Translator
-import numpy as np
+from werkzeug.utils import secure_filename
+import google.generativeai as genai
+import base64
+import json
+from datetime import datetime, timedelta
+import threading
+import time
+from gtts import gTTS  # <-- New import for audio generation
+
+
+
+# Configure the Gemini API
+GEMINI_API_KEY = "AIzaSyBtXV2xJbrWVV57B5RWy_meKXOA59HFMeY"
+if not GEMINI_API_KEY:
+    raise ValueError("Google API Key not found. Set it as GEMINI_API_KEY in the Space settings.")
+
+genai.configure(api_key=GEMINI_API_KEY)
+
+# Setup the Gemini model
+model = genai.GenerativeModel('gemini-1.5-flash')
 
 app = Flask(__name__)
+app.secret_key = os.getenv("SECRET_KEY", "your-default-secret-key-for-flash-messages")
 
-# Initialize translator
-translator = Translator()
-
-# Translation dictionaries
-MARATHI_TRANSLATIONS = {
-    'state': 'राज्य',
-    'district': 'जिल्हा',
-    'market': 'बाजार',
-    'commodity': 'पीक',
-    'variety': 'प्रकार',
-    'grade': 'श्रेणी',
-    'arrival_date': 'आगमन तारीख',
-    'min_price': 'किमान किंमत',
-    'max_price': 'कमाल किंमत',
-    'modal_price': 'सरासरी किंमत',
-    'Select State': 'राज्य निवडा',
-    'Select District': 'जिल्हा निवडा',
-    'Select Market': 'बाजार निवडा',
-    'Select Commodity': 'पीक निवडा',
-    'Market Data': 'बाजार माहिती',
-    'Top 5 Cheapest Crops': 'सर्वात स्वस्त 5 पिके',
-    'Top 5 Costliest Crops': 'सर्वात महाग 5 पिके'
-}
-
-
-def translate_to_marathi(text):
-    """Translate text to Marathi"""
-    try:
-        if text in MARATHI_TRANSLATIONS:
-            return MARATHI_TRANSLATIONS[text]
-        translation = translator.translate(text, dest='mr')
-        return translation.text
-    except:
-        return text
+# Configure upload folder
+UPLOAD_FOLDER = 'static/uploads'
+ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg', 'gif'}
 
+if not os.path.exists(UPLOAD_FOLDER):
+    os.makedirs(UPLOAD_FOLDER)
 
-def fetch_market_data(state=None, district=None, market=None, commodity=None):
-    """Fetch data from the agricultural market API"""
-    api_key = os.getenv("data_api_key")
-    print(api_key)
-    base_url = "1https://api.data.gov.in/resource/9ef84268-d588-465a-a308-a864a43d0070"
+# Configure audio folder (new)
+AUDIO_FOLDER = 'static/audio'
+if not os.path.exists(AUDIO_FOLDER):
+    os.makedirs(AUDIO_FOLDER)
 
-    params = {
-        "api-key": api_key,
-        "format": "json",
-        "limit": 15000,
-    }
+app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
 
-    # Add filters if provided
-    if state:
-        params["filters[state]"] = state
-    if district:
-        params["filters[district]"] = district
-    if market:
-        params["filters[market]"] = market
-    if commodity:
-        params["filters[commodity]"] = commodity
 
-    try:
-        response = requests.get(base_url, params=params)
-        if response.status_code == 200:
-            data = response.json()
-            records = data.get("records", [])
-            df = pd.DataFrame(records)
-            return df
-        else:
-            print(f"API Error: {response.status_code}")
-            return pd.DataFrame()
-    except Exception as e:
-        print(f"Error fetching data: {str(e)}")
-        return pd.DataFrame()
+def allowed_file(filename):
+    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+
 
+def encode_image(image_path):
+    with open(image_path, "rb") as image_file:
+        return base64.b64encode(image_file.read()).decode('utf-8')
 
-def get_ai_insights(market_data, state, district):
-    """Get enhanced insights from LLM API with focus on profitable suggestions for farmers"""
-    if not state or not district or market_data.empty:
-        return ""
 
+def get_web_pesticide_info(disease, plant_type="Unknown"):
+    """Fetch pesticide information from web sources for a specific disease and plant type"""
+    query = f"site:agrowon.esakal.com {disease} in {plant_type}"
+    url = "https://www.googleapis.com/customsearch/v1"
+    params = {
+        "key": os.getenv("GOOGLE_API_KEY"),
+        "cx": os.getenv("GOOGLE_CX"),
+        "q": query,
+        "num": 3
+    }
     try:
-        # Calculate additional market metrics
-        district_data = market_data[market_data['district'] == district]
-
-        # Price trends and volatility
-        price_trends = district_data.groupby('commodity').agg({
-            'modal_price': ['mean', 'min', 'max', 'std']
-        }).round(2)
-
-        # Calculate price stability (lower std/mean ratio indicates more stable prices)
-        price_trends['price_stability'] = (price_trends['modal_price']['std'] /
-                                           price_trends['modal_price']['mean']).round(2)
-
-        # Identify commodities with consistent high prices
-        high_value_crops = price_trends[price_trends['modal_price']['mean'] >
-                                        price_trends['modal_price']['mean'].median()]
-
-        # Get seasonal patterns
-        district_data['arrival_date'] = pd.to_datetime(district_data['arrival_date'])
-        district_data['month'] = district_data['arrival_date'].dt.month
-        monthly_trends = district_data.groupby(['commodity', 'month'])['modal_price'].mean().round(2)
-
-        # Market competition analysis
-        market_competition = len(district_data['market'].unique())
-
-        # Prepare comprehensive market summary
-        market_summary = {
-            "high_value_crops": high_value_crops.index.tolist(),
-            "price_stability": price_trends['price_stability'].to_dict(),
-            "monthly_trends": monthly_trends.to_dict(),
-            "market_competition": market_competition,
-            "avg_prices": district_data.groupby('commodity')['modal_price'].mean().round(2).to_dict(),
-            "price_ranges": {
-                crop: {
-                    'min': price_trends.loc[crop, ('modal_price', 'min')],
-                    'max': price_trends.loc[crop, ('modal_price', 'max')]
-                } for crop in price_trends.index
+        response = requests.get(url, params=params)
+        response.raise_for_status()
+        data = response.json()
+        if "items" in data and len(data["items"]) > 0:
+            item = data["items"][0]
+            return {
+                "title": item.get("title", "No title available"),
+                "link": item.get("link", "#"),
+                "snippet": item.get("snippet", "No snippet available"),
+                "summary": item.get("snippet", "No snippet available")
             }
-        }
-
-        # Enhanced LLM prompt for more actionable insights
-        prompt = f"""
-        As an agricultural market expert, analyze this data for {district}, {state} and provide specific, actionable advice for farmers:
-
-        Market Overview:
-        - Number of active markets: {market_competition}
-        - High-value crops: {', '.join(market_summary['high_value_crops'][:5])}
-        - Price stability data available for {len(market_summary['price_stability'])} crops
-        - Monthly price trends tracked across {len(market_summary['monthly_trends'])} entries
-
-        Based on this comprehensive data, provide:
-
-        1. Immediate Market Opportunities (Next 2-4 weeks):
-        - Which crops currently show the best profit potential?
-        - Which markets are offering the best prices?
-        - Any immediate selling or holding recommendations?
-
-        2. Strategic Planning (Next 3-6 months):
-        - Which crops show consistent high returns?
-        - What are the optimal planting times based on price patterns?
-        - Which crop combinations could maximize profit throughout the year?
-
-        3. Risk Management:
-        - Which crops have shown the most stable prices?
-        - How can farmers diversify their crops to minimize risk?
-        - What are the warning signs to watch for in the market?
-
-        4. Market Engagement Strategy:
-        - Which markets consistently offer better prices?
-        - What quality grades are fetching premium prices?
-        - How can farmers negotiate better based on current market dynamics?
-
-        5. Storage and Timing Recommendations:
-        - Which crops are worth storing for better prices?
-        - What are the best times to sell each major crop?
-        - How can farmers use price trends to time their sales?
-
-        Provide practical, actionable advice that farmers can implement immediately. Include specific numbers and percentages where relevant.
-        Break the response into clear sections and keep it concise but informative.
-        """
-        api_url = "https://api-inference.huggingface.co/models/meta-llama/Llama-3.2-1B-Instruct/v1/chat/completions"
-        headers = {"Authorization": f"Bearer {os.getenv('HUGGINGFACE_API_KEY')}"}
+    except Exception as e:
+        print(f"Error retrieving web pesticide info: {str(e)}")
+    return None
 
-        payload = {
-            "inputs": prompt
-        }
 
-        response = requests.post(api_url, headers=headers, json=payload)
-        if response.status_code == 200:
-            response_data = response.json()
-            if (response_data and
-                    'choices' in response_data and
-                    len(response_data['choices']) > 0 and
-                    'message' in response_data['choices'][0] and
-                    'content' in response_data['choices'][0]['message']):
-                insights = response_data['choices'][0]['message']['content']
-                formatted_insights = format_ai_insights(insights)
-                return formatted_insights
+def get_more_web_info(query):
+    """Get more general web information based on a search query"""
+    url = "https://www.googleapis.com/customsearch/v1"
+    params = {
+        "key": os.getenv("GOOGLE_API_KEY"),
+        "cx": os.getenv("GOOGLE_CX"),
+        "q": query,
+        "num": 3
+    }
+    try:
+        response = requests.get(url, params=params)
+        response.raise_for_status()
+        data = response.json()
+        results = []
+        if "items" in data:
+            for item in data["items"]:
+                results.append({
+                    "title": item.get("title", "No title available"),
+                    "link": item.get("link", "#"),
+                    "snippet": item.get("snippet", "No snippet available")
+                })
+        return results
+    except Exception as e:
+        print(f"Error retrieving additional articles: {str(e)}")
+    return []
 
-        return "AI insights temporarily unavailable"
 
+def get_commercial_product_info(recommendation, disease_name):
+    """Fetch commercial product information related to a pesticide recommendation.
+    If no relevant products are found from web sources, return default products based on issue type:
+    bacterial, fungicide (disease), or insecticide.
+    """
+    indiamart_query = f"site:indiamart.com pesticide '{disease_name}' '{recommendation}'"
+    krishi_query = f"site:krishisevakendra.in/products pesticide '{disease_name}' '{recommendation}'"
+
+    indiamart_results = get_more_web_info(indiamart_query)
+    krishi_results = get_more_web_info(krishi_query)
+
+    results = indiamart_results + krishi_results
+
+    if not results:
+        lower_disease = disease_name.lower()
+        lower_recommendation = recommendation.lower()
+
+        if ("bacteria" in lower_disease or "bacterial" in lower_disease or
+                "bacteria" in lower_recommendation or "bacterial" in lower_recommendation):
+            results = [
+                {
+                    "title": "UPL SAAF Carbendazin Mancozeb Bactericide",
+                    "link": "https://www.amazon.in/UPL-SAAF-Carbendazinm12-Mancozeb63-Action/dp/B0DJLQRL44",
+                    "snippet": "Bactericide for controlling bacterial infections."
+                },
+                {
+                    "title": "Tropical Tagmycin Bactericide",
+                    "link": "https://krushidukan.bharatagri.com/en/products/tropical-tagmycin-bactericide",
+                    "snippet": "Bactericide for effective bacterial infection management."
+                }
+            ]
+        elif ("fungus" in lower_disease or "fungicide" in lower_recommendation or
+              "antibiotic" in lower_recommendation or "disease" in lower_disease):
+            results = [
+                {
+                    "title": "Plantomycin Bio Organic Antibiotic Effective Disease",
+                    "link": "https://www.amazon.in/Plantomycin-Bio-Organic-Antibiotic-Effective-Disease/dp/B0DRVVJKQ4",
+                    "snippet": "Bio organic antibiotic for effective control of plant diseases."
+                },
+                {
+                    "title": "WET-TREE Larvicide Thuringiensis Insecticide",
+                    "link": "https://www.amazon.in/WET-TREE-Larvicide-Thuringiensis-Insecticide/dp/B0D6R72KHV",
+                    "snippet": "Larvicide with thuringiensis for disease prevention."
+                }
+            ]
+        elif ("insecticide" in lower_disease or "insect" in lower_disease or "pest" in lower_disease or
+              "insecticide" in lower_recommendation or "insect" in lower_recommendation or "pest" in lower_recommendation):
+            results = [
+                {
+                    "title": "Syngenta Actara Insecticide",
+                    "link": "https://www.amazon.in/syngenta-Actara-Insect-Repellent-Insecticide/dp/B08W55XTHS",
+                    "snippet": "Effective systemic insecticide for pest control."
+                },
+                {
+                    "title": "Cyhalothrin Insecticide",
+                    "link": "https://www.amazon.in/Cyhalothrin-Control-Eradication-Mosquitoes-Crawling/dp/B01N53VH1T",
+                    "snippet": "Broad-spectrum insecticide for pest management."
+                }
+            ]
+        else:
+            results = [
+                {
+                    "title": "Syngenta Actara Insecticide",
+                    "link": "https://www.amazon.in/syngenta-Actara-Insect-Repellent-Insecticide/dp/B08W55XTHS",
+                    "snippet": "Effective systemic insecticide for pest control."
+                },
+                {
+                    "title": "Cyhalothrin Insecticide",
+                    "link": "https://www.amazon.in/Cyhalothrin-Control-Eradication-Mosquitoes-Crawling/dp/B01N53VH1T",
+                    "snippet": "Broad-spectrum insecticide for pest management."
+                }
+            ]
+
+    return results
+
+
+def get_relevant_feedback(plant_name):
+    """Retrieve feedback entries relevant to the given plant name from feedback.json."""
+    feedback_file = "feedback.json"
+    if os.path.exists(feedback_file):
+        try:
+            with open(feedback_file, "r") as f:
+                all_feedback = json.load(f)
+            relevant = [entry.get("feedback") for entry in all_feedback if
+                        entry.get("plant_name", "").lower() == plant_name.lower()]
+            if relevant:
+                return " ".join(relevant[:3])
+        except Exception as e:
+            print(f"Error reading feedback for reinforcement: {e}")
+    return ""
+
+
+def generate_audio(text, language, filename):
+    """Generate an MP3 file from text using gTTS."""
+    try:
+        tts = gTTS(text=text, lang=language, slow=False)
+        tts.save(filename)
     except Exception as e:
-        print(f"Error generating insights: {str(e)}")
-        return f"Could not generate insights: {str(e)}"
-
-
-def generate_plots(df, lang='en'):
-    """Generate all plots with language support"""
-    if df.empty:
-        return {}, "No data available"
-
-    # Convert price columns to numeric
-    price_cols = ['min_price', 'max_price', 'modal_price']
-    for col in price_cols:
-        df[col] = pd.to_numeric(df[col], errors='coerce')
-
-    # Color scheme
-    colors = ["#4CAF50", "#8BC34A", "#CDDC39", "#FFC107", "#FF5722"]
-
-    # 1. Bar Chart
-    df_bar = df.groupby('commodity')['modal_price'].mean().reset_index()
-    fig_bar = px.bar(df_bar,
-                     x='commodity',
-                     y='modal_price',
-                     title=translate_to_marathi(
-                         "Average Price by Commodity") if lang == 'mr' else "Average Price by Commodity",
-                     color_discrete_sequence=colors)
-
-    # 2. Line Chart (if commodity selected)
-    fig_line = None
-    if 'commodity' in df.columns and len(df['commodity'].unique()) == 1:
-        df['arrival_date'] = pd.to_datetime(df['arrival_date'])
-        df_line = df.sort_values('arrival_date')
-        fig_line = px.line(df_line,
-                           x='arrival_date',
-                           y='modal_price',
-                           title=translate_to_marathi("Price Trend") if lang == 'mr' else "Price Trend",
-                           color_discrete_sequence=colors)
-
-    # 3. Box Plot
-    fig_box = px.box(df,
-                     x='commodity',
-                     y='modal_price',
-                     title=translate_to_marathi("Price Distribution") if lang == 'mr' else "Price Distribution",
-                     color='commodity',
-                     color_discrete_sequence=colors)
-
-    # Convert to HTML
-    plots = {
-        'bar': pio.to_html(fig_bar, full_html=False),
-        'box': pio.to_html(fig_box, full_html=False)
-    }
-    if fig_line:
-        plots['line'] = pio.to_html(fig_line, full_html=False)
+        print(f"Error generating audio: {e}")
 
-    return plots
 
+def analyze_plant_image(image_path, plant_name, language):
+    try:
+        # Load the image
+        image_parts = [
+            {
+                "mime_type": "image/jpeg",
+                "data": encode_image(image_path)
+            }
+        ]
 
-@app.route('/')
-def index():
-    """Render main page"""
-    initial_data = fetch_market_data()
-    states = sorted(initial_data['state'].dropna().unique())
-    return render_template('index.html',
-                           states=states,
-                           today=datetime.today().strftime('%Y-%m-%d'))
-
-
-@app.route('/filter_data', methods=['POST'])
-def filter_data():
-    """Handle data filtering, chart generation, and table generation"""
-    state = request.form.get('state')
-    district = request.form.get('district')
-    market = request.form.get('market')
-    commodity = request.form.get('commodity')
-    lang = request.form.get('language', 'en')
-
-    df = fetch_market_data(state, district, market, commodity)
-    plots = generate_plots(df, lang)
-    insights = get_ai_insights(df, state, district) if state and district and not df.empty else ""
-
-    # Generate market data table HTML
-    market_table_html = """
-    <div class="table-responsive">
-        <table class="table table-striped table-bordered">
-            <thead>
-                <tr>
-                    <th>State</th>
-                    <th>District</th>
-                    <th>Market</th>
-                    <th>Commodity</th>
-                    <th>Variety</th>
-                    <th>Grade</th>
-                    <th>Arrival Date</th>
-                    <th>Min Price</th>
-                    <th>Max Price</th>
-                    <th>Modal Price</th>
-                </tr>
-            </thead>
-            <tbody>
-    """
+        # Load relevant feedback (reinforcement data) for this plant
+        feedback_context = get_relevant_feedback(plant_name)
+        feedback_instruction = f" Please consider the following user feedback from similar cases: {feedback_context}" if feedback_context else ""
 
-    for _, row in df.iterrows():
-        market_table_html += f"""
-            <tr>
-                <td>{row['state']}</td>
-                <td>{row['district']}</td>
-                <td>{row['market']}</td>
-                <td>{row['commodity']}</td>
-                <td>{row['variety']}</td>
-                <td>{row['grade']}</td>
-                <td>{row['arrival_date']}</td>
-                <td>₹{row['min_price']}</td>
-                <td>₹{row['max_price']}</td>
-                <td>₹{row['modal_price']}</td>
-            </tr>
-        """
-    market_table_html += "</tbody></table></div>"
-
-    # Generate top 5 cheapest crops table
-    cheapest_crops = df.sort_values('modal_price', ascending=True).head(5)
-    cheapest_table_html = """
-    <div class="table-responsive">
-        <table class="table table-sm table-bordered">
-            <thead>
-                <tr>
-                    <th>Commodity</th>
-                    <th>Market</th>
-                    <th>Modal Price</th>
-                </tr>
-            </thead>
-            <tbody>
-    """
+        # Create prompt for Gemini API with language instruction and feedback reinforcement if available
+        prompt = f"""
+        Analyze this image of a {plant_name} plant and prioritize determining if it's healthy or has a disease or pest infestation.
 
-    for _, row in cheapest_crops.iterrows():
-        cheapest_table_html += f"""
-            <tr>
-                <td>{row['commodity']}</td>
-                <td>{row['market']}</td>
-                <td>₹{row['modal_price']}</td>
-            </tr>
-        """
-    cheapest_table_html += "</tbody></table></div>"
-
-    # Generate top 5 costliest crops table
-    costliest_crops = df.sort_values('modal_price', ascending=False).head(5)
-    costliest_table_html = """
-    <div class="table-responsive">
-        <table class="table table-sm table-bordered">
-            <thead>
-                <tr>
-                    <th>Commodity</th>
-                    <th>Market</th>
-                    <th>Modal Price</th>
-                </tr>
-            </thead>
-            <tbody>
-    """
+        If a disease or pest is detected, provide the following information in JSON format:
+        {{"results": [{{"type": "disease/pest", "name": "Name of disease or pest", "probability": "Probability as a percentage", "symptoms": "Describe the visible symptoms", "causes": "Main causes of the disease or pest", "severity": "Low/Medium/High", "spreading": "How it spreads", "treatment": "Treatment options", "prevention": "Preventive measures"}},{{}},{{}}], "is_healthy": boolean indicating if the plant appears healthy, "confidence": "Overall confidence in the analysis as a percentage"}}
 
-    for _, row in costliest_crops.iterrows():
-        costliest_table_html += f"""
-            <tr>
-                <td>{row['commodity']}</td>
-                <td>{row['market']}</td>
-                <td>₹{row['modal_price']}</td>
-            </tr>
+        Only return the JSON data and nothing else. Ensure the JSON is valid and properly formatted.
+        If the plant appears completely healthy, set is_healthy to true and include an empty results array.
+        Additionally, provide the response in {language} language.
+        and at end show which all data from feedback was taken into consideration and if no data was taken so no data.
         """
-    costliest_table_html += "</tbody></table></div>"
-
-    # Calculate market statistics
-    market_stats = {
-        'total_commodities': len(df['commodity'].unique()),
-        'avg_modal_price': f"₹{df['modal_price'].mean():.2f}",
-        'price_range': f"₹{df['modal_price'].min():.2f} - ₹{df['modal_price'].max():.2f}",
-        'total_markets': len(df['market'].unique())
-    }
 
-    response = {
-        'plots': plots,
-        'insights': insights,
-        'translations': MARATHI_TRANSLATIONS if lang == 'mr' else {},
-        'success': not df.empty,
-        'hasStateDistrict': bool(state and district),
-        'market_html': market_table_html,
-        'cheapest_html': cheapest_table_html,
-        'costliest_html': costliest_table_html,
-        'market_stats': market_stats
-    }
+        # Send request to Gemini API
+        response = model.generate_content([prompt] + image_parts)
 
-    return jsonify(response)
-
-
-def format_ai_insights(insights_data, lang='en'):
-    """Format AI insights into structured HTML with language support"""
-    # Translation dictionary for section headers and labels
-    translations = {
-        'AI Market Insights': 'एआय बाजार विश्लेषण',
-        'Immediate Market Opportunities': 'तात्काळ बाजार संधी',
-        'Best Profit Potential': 'सर्वोत्तम नफा क्षमता',
-        'Current Market Status': 'सध्याची बाजार स्थिती',
-        'Strategic Planning': 'धोरणात्मक नियोजन',
-        'High Return Crops': 'उच्च परतावा पिके',
-        'Recommended Crop Combinations': 'शिफारस केलेली पीक संयोजने',
-        'Risk Management & Market Strategy': 'जोखीम व्यवस्थापन आणि बाजार धोरण',
-        'Recommended Actions': 'शिफारस केलेल्या कृती',
-        'increase': 'वाढ',
-        'per kg': 'प्रति किलो',
-        'Most stable prices': 'सर्वात स्थिर किंमती',
-        'Best storage life': 'सर्वोत्तम साठवण कालावधी',
-        'Peak selling time': 'उच्चतम विक्री काळ',
-        'Plant mix of': 'पिकांचे मिश्रण लावा',
-        'Focus on': 'लक्ष केंद्रित करा',
-        'Store': 'साठवण करा',
-        'Aim for': 'लक्ष्य ठेवा',
-        'months': 'महिने'
-    }
+        # Extract the JSON response
+        response_text = response.text
 
-    def translate_text(text):
-        """Translate text based on language selection"""
-        if lang == 'mr':
-            # Try to find direct translation from dictionary
-            for eng, mar in translations.items():
-                text = text.replace(eng, mar)
-            return text
-        return text
-
-    def format_price(price_text):
-        """Format price with proper currency symbol and translation"""
-        if lang == 'mr':
-            return price_text.replace('₹', '₹').replace('per kg', 'प्रति किलो')
-        return price_text
-
-    """Format AI insights into structured HTML"""
-    html = f"""
-    <div class="insights-header">
-        <h3 class="en">AI Market Insights</h3>
-        <h3 class="mr" style="display:none;">एआय बाजार विश्लेषण</h3>
-    </div>
-
-    <div class="insight-section">
-        <h4>Immediate Market Opportunities</h4>
-        <div class="insight-card">
-            <h5>Best Profit Potential</h5>
-            <ul class="insight-list">
-                <li>Beetroot and Bitter gourd showing <span class="percentage-up">15% increase</span> from base year</li>
-                <li>Bottle gourd premium quality fetching <span class="price-highlight">₹150 per kg</span></li>
-            </ul>
-        </div>
-
-        <div class="insight-card">
-            <h5>Current Market Status</h5>
-            <ul class="insight-list">
-                <li>Brinjal in high demand with stable price of <span class="price-highlight">₹80 per kg</span></li>
-                <li>Premium quality bottle gourd commanding <span class="price-highlight">₹200 per kg</span></li>
-            </ul>
-        </div>
-    </div>
-
-    <div class="insight-section">
-        <h4>Strategic Planning</h4>
-        <div class="insight-card">
-            <h5>High Return Crops</h5>
-            <ul class="insight-list">
-                <li>Cauliflower showing <span class="percentage-up">20% increase</span> from base year</li>
-                <li>Best planting time: Spring season for cauliflower and bottle gourd</li>
-            </ul>
-        </div>
-
-        <div class="insight-card">
-            <h5>Recommended Crop Combinations</h5>
-            <ul class="insight-list">
-                <li>Brinjal + Bottle gourd + Cauliflower (similar demand patterns)</li>
-            </ul>
-        </div>
-    </div>
-
-    <div class="insight-section">
-        <h4>Risk Management & Market Strategy</h4>
-        <div class="insight-card">
-            <ul class="insight-list">
-                <li>Most stable prices: Brinjal, Bottle gourd, Cauliflower</li>
-                <li>Best storage life: 6-9 months for Cauliflower, Brinjal, and Bottle gourd</li>
-                <li>Peak selling time for Cauliflower: March-April</li>
-            </ul>
-        </div>
-    </div>
-
-    <div class="action-box">
-        <h5>Recommended Actions</h5>
-        <ul class="action-list">
-            <li>Plant mix of beetroot, bitter gourd, bottle gourd, brinjal, and cauliflower</li>
-            <li>Focus on stable price markets for cauliflower and bottle gourd</li>
-            <li>Store cauliflower for March-April peak prices</li>
-            <li>Aim for premium quality grades to maximize profits</li>
-        </ul>
-    </div>
-    """
-    if lang == 'mr':
-        html = translate_text(html)
-        # print(html
-        return html
+        # Find JSON within response text if needed
+        json_start = response_text.find('{')
+        json_end = response_text.rfind('}') + 1
+
+        if json_start >= 0 and json_end > 0:
+            json_str = response_text[json_start:json_end]
+            analysis_result = json.loads(json_str)
+        else:
+            return {
+                "error": "Failed to parse the API response",
+                "raw_response": response_text
+            }
 
-    return html
+        # ---- Added audio generation feature ----
+        # Create a summary text based on the analysis including Spreading, Treatment, and Prevention
+        if analysis_result.get('is_healthy', False):
+            summary_text = f"Your {plant_name} plant appears to be healthy. Continue with your current care practices."
+        elif 'results' in analysis_result and analysis_result['results']:
+            summary_text = "Detected issues: "
+            for result in analysis_result['results']:
+                summary_text += (f"{result.get('name', 'Unknown')}. Symptoms: {result.get('symptoms', '')}. "
+                                 f"Causes: {result.get('causes', '')}. Spreading: {result.get('spreading', '')}. "
+                                 f"Treatment: {result.get('treatment', '')}. Prevention: {result.get('prevention', '')}. ")
+        else:
+            summary_text = "Analysis inconclusive."
 
+        # Map language name to gTTS language code
+        lang_mapping = {"English": "en", "Hindi": "hi", "Bengali": "bn", "Telugu": "te", "Marathi": "mr", "Tamil": "ta",
+                        "Gujarati": "gu", "Urdu": "ur", "Kannada": "kn", "Odia": "or", "Malayalam": "ml"}
+        gtts_lang = lang_mapping.get(language, 'en')
 
-@app.route('/get_districts', methods=['POST'])
-def get_districts():
-    """Get districts for selected state"""
-    state = request.form.get('state')
-    df = fetch_market_data(state=state)
-    districts = sorted(df['district'].dropna().unique())
-    return jsonify(districts)
+        # Generate unique audio filename
+        timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
+        audio_filename = f"audio_result.mp3"
+        audio_path = os.path.join(AUDIO_FOLDER, audio_filename)
+        generate_audio(summary_text, gtts_lang, audio_path)
 
+        # Wait until the audio file is created and has nonzero size (up to 5 seconds)
+        wait_time = 0
+        while (not os.path.exists(audio_path) or os.path.getsize(audio_path) == 0) and wait_time < 5:
+            time.sleep(0.5)
+            wait_time += 0.5
 
-@app.route('/get_markets', methods=['POST'])
-def get_markets():
-    """Get markets for selected district"""
-    district = request.form.get('district')
-    df = fetch_market_data(district=district)
-    markets = sorted(df['market'].dropna().unique())
-    return jsonify(markets)
+        # Add relative audio file path for template rendering
+        analysis_result['audio_file'] = os.path.join('audio', audio_filename)
+        # -----------------------------------------
 
+        return analysis_result
 
-@app.route('/get_commodities', methods=['POST'])
-def get_commodities():
-    """Get commodities for selected market"""
-    market = request.form.get('market')
-    df = fetch_market_data(market=market)
-    commodities = sorted(df['commodity'].dropna().unique())
-    return jsonify(commodities)
+    except Exception as e:
+        return {
+            "error": str(e),
+            "is_healthy": None,
+            "results": []
+        }
 
 
-if __name__== '__main__':
-    app.run(host='0.0.0.0', port=7860)
+def cleanup_old_files(directory, max_age_hours=1):  # Reduced to 1 hour for Hugging Face
+    """Remove files older than the specified age from the directory"""
+    while True:
+        now = datetime.now()
+        for filename in os.listdir(directory):
+            if filename == '.gitkeep':  # Skip the .gitkeep file
+                continue
+            file_path = os.path.join(directory, filename)
+            file_age = now - datetime.fromtimestamp(os.path.getctime(file_path))
+            if file_age > timedelta(hours=max_age_hours):
+                try:
+                    os.remove(file_path)
+                    print(f"Removed old file: {file_path}")
+                except Exception as e:
+                    print(f"Error removing {file_path}: {e}")
+        time.sleep(300)  # 5 minutes
+
+
+@app.route('/', methods=['GET'])
+def index():
+    # GET request - show the upload form
+    return render_template('index.html', show_results=False)
+
+
+@app.route('/feedback', methods=['POST'])
+def feedback():
+    # Get feedback from form submission
+    feedback_text = request.form.get("feedback")
+    plant_name = request.form.get("plant_name", "Unknown")
+    if not feedback_text:
+        flash("Please provide your feedback before submitting.")
+        return redirect(url_for('index'))
+    feedback_data = {
+        "plant_name": plant_name,
+        "feedback": feedback_text,
+        "timestamp": datetime.now().isoformat()
+    }
+    feedback_file = "feedback.json"
+    if os.path.exists(feedback_file):
+        try:
+            with open(feedback_file, "r") as f:
+                existing_feedback = json.load(f)
+        except Exception as e:
+            print(f"Error reading feedback file: {e}")
+            existing_feedback = []
+    else:
+        existing_feedback = []
+    existing_feedback.append(feedback_data)
+    try:
+        with open(feedback_file, "w") as f:
+            json.dump(existing_feedback, f, indent=4)
+    except Exception as e:
+        flash(f"Error saving your feedback: {str(e)}")
+        return redirect(url_for('index'))
+    flash("Thank you for your feedback!")
+    return redirect(url_for('index'))
+
+
+@app.route('/analyze', methods=['POST'])
+def analyze():
+    if 'plant_image' not in request.files:
+        flash('No file part')
+        return redirect(url_for('index'))
+
+    file = request.files['plant_image']
+    plant_name = request.form.get('plant_name', 'unknown')
+    language = request.form.get('language', 'English')
+
+    if file.filename == '':
+        flash('No selected file')
+        return redirect(url_for('index'))
+
+    if file and allowed_file(file.filename):
+        timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
+        original_filename = secure_filename(file.filename)
+        filename = f"{timestamp}_{original_filename}"
+        file_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+        file.save(file_path)
+
+        try:
+            analysis_result = analyze_plant_image(file_path, plant_name, language)
+            if 'error' in analysis_result:
+                flash(f"Error analyzing image: {analysis_result['error']}")
+                if os.path.exists(file_path):
+                    os.remove(file_path)
+                return redirect(url_for('index'))
+            web_info = {}
+            product_info = {}
+            if not analysis_result.get('is_healthy', False) and 'results' in analysis_result:
+                for result in analysis_result['results']:
+                    disease_name = result.get('name', '')
+                    if disease_name:
+                        web_info[disease_name] = get_web_pesticide_info(disease_name, plant_name)
+                        treatment = result.get('treatment', '')
+                        if treatment:
+                            product_info[disease_name] = get_commercial_product_info(treatment, disease_name)
+            response = render_template(
+                'results.html',
+                results=analysis_result,
+                plant_name=plant_name,
+                image_path=file_path.replace('static/', '', 1),
+                web_info=web_info,
+                product_info=product_info
+            )
+
+            def delete_file_after_delay(path, delay=30):
+                time.sleep(delay)
+                if os.path.exists(path):
+                    try:
+                        os.remove(path)
+                        print(f"Deleted analyzed file: {path}")
+                    except Exception as e:
+                        print(f"Error deleting {path}: {e}")
+
+            threading.Thread(
+                target=delete_file_after_delay,
+                args=(file_path,),
+                daemon=True
+            ).start()
+
+            return response
+
+        except Exception as e:
+            flash(f"An error occurred: {str(e)}")
+            if os.path.exists(file_path):
+                os.remove(file_path)
+            return redirect(url_for('index'))
+
+    flash('Invalid file type. Please upload an image (png, jpg, jpeg, gif).')
+    return redirect(url_for('index'))
+
+
+if __name__ == '__main__':
+    cleanup_thread = threading.Thread(target=cleanup_old_files, args=(app.config['UPLOAD_FOLDER'],), daemon=True)
+    cleanup_thread.start()
+    port = int(os.environ.get("PORT", 7860))
+    app.run(host='0.0.0.0', port=port)