Update app.py

app.py

@@ -9,11 +9,12 @@ from flask import (
     make_response, redirect, url_for
 )
 from werkzeug.middleware.proxy_fix import ProxyFix
+from flask_session import Session
 import google.generativeai as genai
 from dotenv import load_dotenv
 from cachelib import SimpleCache
 
-# Load .env
+# Load environment
 load_dotenv()
 
 # Logging
@@ -26,33 +27,40 @@ app = Flask(__name__, static_folder="static", template_folder="templates")
 # Secret key
 app.secret_key = os.getenv("FLASK_SECRET_KEY", os.urandom(24))
 
-# ProxyFix - trust one proxy layer (adjust numbers if you sit behind more proxies)
+# ProxyFix for deployments behind proxies (Hugging Face)
 app.wsgi_app = ProxyFix(app.wsgi_app, x_for=1, x_proto=1, x_host=1, x_port=1, x_prefix=1)
 
-# Cookie / session policy (sane defaults for Hugging Face Spaces)
-# By default we set SECURE cookies and SameSite=None which is required for cross-site in modern browsers.
-# If you are running locally over HTTP, set DISABLE_SECURE_COOKIE=1 in your environment (for development only).
+# Session configuration (filesystem-based) -- persists server-side during container life
+# Flask-Session will write files under /tmp by default
+app.config["SESSION_TYPE"] = "filesystem"
+app.config["SESSION_FILE_DIR"] = os.getenv("SESSION_FILE_DIR", "/tmp/flask_session")
+app.config["SESSION_PERMANENT"] = True
+app.config["PERMANENT_SESSION_LIFETIME"] = timedelta(days=7)
+
+# Cookie settings - browsers require SameSite=None + Secure for cross-site cookies
 disable_secure = os.getenv("DISABLE_SECURE_COOKIE", "0") in ("1", "true", "True")
 app.config["SESSION_COOKIE_SAMESITE"] = "None"
 app.config["SESSION_COOKIE_SECURE"] = False if disable_secure else True
-app.config["PERMANENT_SESSION_LIFETIME"] = timedelta(days=7)
-app.config["SESSION_PERMANENT"] = True
 app.config["SESSION_COOKIE_NAME"] = os.getenv("SESSION_COOKIE_NAME", "hf_app_session")
 
-# Simple in-memory cache (for details from the Gemini API)
-cache = SimpleCache(threshold=200, default_timeout=60 * 60 * 24 * 7)  # 7 days default timeout
+# Initialize server-side sessions
+Session(app)
+
+# Simple in-memory cache (for API results)
+cache = SimpleCache(threshold=200, default_timeout=60 * 60 * 24 * 7)  # 7 days
 
-# Configure Gemini (Gemini API key must be set in environment as GEMINI_API_KEY)
+# Gemini API
 GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
 if GEMINI_API_KEY:
     try:
         genai.configure(api_key=GEMINI_API_KEY)
+        logger.info("Gemini client configured.")
     except Exception as e:
         logger.exception("Failed to configure Gemini client: %s", e)
 else:
-    logger.warning("GEMINI_API_KEY not provided. API calls will not work until you set this env var.")
+    logger.warning("GEMINI_API_KEY not set. API calls will return placeholders.")
 
-# Supported languages and list of pests/diseases (kept from your original list)
+# Supported languages and pest list (original)
 LANGUAGES = {
     "en": "English", "hi": "हिंदी (Hindi)", "bn": "বাংলা (Bengali)", "te": "తెలుగు (Telugu)",
     "mr": "मराठी (Marathi)", "ta": "தமிழ் (Tamil)", "gu": "ગુજરાતી (Gujarati)", "ur": "اردو (Urdu)",
@@ -74,82 +82,69 @@ PESTS_DISEASES = [
     {"id": 12, "name": "Fusarium Wilt", "type": "disease", "crop": "Banana, Tomato", "image_url": "/static/images/fusarium_wilt.jpg"}
 ]
 
-# Utility: robust JSON extraction from potentially noisy model output
+# JSON extraction helper (resilient to noisy model output)
 def extract_json_from_response(content: str):
     try:
         return json.loads(content)
     except json.JSONDecodeError:
-        # Attempt to extract codeblock containing JSON
         json_match = re.search(r'```json(.*?)```', content, re.DOTALL)
         if json_match:
             json_str = json_match.group(1).strip()
         else:
-            # Fallback: try to extract first {...} block
             brace_match = re.search(r'(\{(?:.|\n)*\})', content)
             json_str = brace_match.group(1) if brace_match else content
-
-        # Remove stray markdown markers and weird trailing commas
         json_str = json_str.replace('```json', '').replace('```', '').strip()
         json_str = re.sub(r',(\s*[\]\}])', r'\1', json_str)
-
         try:
             return json.loads(json_str)
         except json.JSONDecodeError as e:
-            logger.error("JSON parsing error after cleanup: %s\nOriginal content: %s", e, content[:1000])
+            logger.error("JSON parsing error after cleanup: %s\nSnippet: %s", e, content[:1000])
             raise ValueError("Failed to parse JSON response from API")
 
-# Root page
 @app.route("/")
 def index():
-    # Determine language: prefer session, fallback to cookie, then default 'en'.
+    # Use session first, cookie fallback. This sets HTML lang attribute properly.
     language = session.get("language") or request.cookies.get("language") or "en"
-    # Keep session in sync with cookie if needed
     session["language"] = language
     session.permanent = True
-    return render_template("pests.html",
-                           pests_diseases=PESTS_DISEASES,
-                           languages=LANGUAGES,
-                           current_language=language)
+    return render_template("index.html", pests_diseases=PESTS_DISEASES, languages=LANGUAGES, current_language=language)
 
-# Language setter (Post-Redirect-Get)
+# Keep this for compatibility; not required if client only sets cookie & passes lang in fetch
 @app.route("/set_language", methods=["POST"])
 def set_language():
     language = request.form.get("language", "en")
     if language not in LANGUAGES:
-        logger.warning("Attempt to set unsupported language: %s", language)
         language = "en"
-
-    # Save in server-side session
     session["language"] = language
     session.permanent = True
-    logger.info("Language successfully changed to %s in session.", language)
+    logger.info("Language set to %s in session", language)
 
-    # Also set a client cookie as reliable fallback for stateless platforms
     resp = make_response(redirect(url_for("index")))
-    # cookie lifetime 7 days
     max_age = 60 * 60 * 24 * 7
     secure_flag = False if disable_secure else True
-    resp.set_cookie("language", language, max_age=max_age, secure=secure_flag, samesite="None", httponly=False)
+    resp.set_cookie("language", language, max_age=max_age, secure=secure_flag, samesite="None", httponly=False, path="/")
     return resp
 
-# Endpoint to fetch details for a pest/disease (uses cache + Gemini)
 @app.route("/get_details/<int:pest_id>")
-def get_details(pest_id: int):
-    # Resolve language (session first, cookie fallback)
-    language = session.get("language") or request.cookies.get("language") or "en"
+def get_details(pest_id):
+    # Priority: lang query param > session > cookie > default
+    lang_param = request.args.get("lang")
+    language = lang_param or session.get("language") or request.cookies.get("language") or "en"
+    session["language"] = language
+    session.permanent = True
 
     pest = next((p for p in PESTS_DISEASES if p["id"] == pest_id), None)
-    if pest is None:
+    if not pest:
         return jsonify({"error": "Not found"}), 404
 
     cache_key = f"pest_{pest_id}_{language}"
     cached = cache.get(cache_key)
     if cached:
-        logger.info("Cache hit for %s (%s)", pest_id, language)
+        logger.info("Cache hit for pest %s (%s)", pest_id, language)
         return jsonify(cached)
 
     if not GEMINI_API_KEY:
-        logger.warning("Gemini API key missing; returning placeholder result.")
+        logger.warning("GEMINI_API_KEY missing; returning placeholder details")
         result = {
             **pest,
             "details": {
@@ -166,7 +161,7 @@ def get_details(pest_id: int):
         cache.set(cache_key, result)
         return jsonify(result)
 
-    # Build prompt with language-specific instruction
+    # Build prompt for Gemini
     lang_instructions = {
         "en": "Respond in English",
         "hi": "हिंदी में जवाब दें (Respond in Hindi)",
@@ -194,12 +189,11 @@ Each key must contain an object with "title" and "text" fields.
         text = getattr(response, "text", "") or str(response)
         detailed_info = extract_json_from_response(text)
 
-        # Ensure keys exist
         required_keys = ["description", "lifecycle", "symptoms", "impact", "management", "prevention"]
         for key in required_keys:
             if key not in detailed_info or "text" not in detailed_info.get(key, {}):
                 detailed_info[key] = {"title": key.capitalize(), "text": "Information could not be generated for this section."}
-                logger.warning("API response missing or malformed for key: %s", key)
+                logger.warning("Missing section in API response: %s", key)
 
         result = {
             **pest,
@@ -210,12 +204,10 @@ Each key must contain an object with "title" and "text" fields.
         cache.set(cache_key, result)
         logger.info("Cached details for pest %s (%s)", pest_id, language)
         return jsonify(result)
-
     except Exception as e:
-        logger.exception("Error fetching details from Gemini API: %s", e)
+        logger.exception("Error fetching from Gemini: %s", e)
         return jsonify({"error": "Failed to fetch information", "message": str(e)}), 500
 
-
 if __name__ == "__main__":
     port = int(os.environ.get("PORT", 7860))
     host = os.environ.get("HOST", "0.0.0.0")