Update app.py

app.py

@@ -1,20 +1,29 @@
-import threading, time
-from flask import Flask, render_template, request, jsonify, Response
+import os
+import hashlib
+import time
+import threading
 import requests
+from flask import Flask, render_template, request, jsonify, Response, send_file, url_for
 from bs4 import BeautifulSoup
 from flask_caching import Cache
 
 app = Flask(__name__)
 
-# Configure caching – here we use a simple in-memory cache.
-# In production you might use Redis or another robust backend.
+# Configure in-memory caching for non-image routes
 app.config['CACHE_TYPE'] = 'SimpleCache'
 app.config['CACHE_DEFAULT_TIMEOUT'] = 300  # Cache responses for 5 minutes
 cache = Cache(app)
 
-# Global variables for pre-fetched image data
-cached_image = None
-cached_mimetype = None
+# Directory to store cached images
+CACHE_DIR = "cache_images"
+if not os.path.exists(CACHE_DIR):
+    os.makedirs(CACHE_DIR)
+
+def get_cache_filename(url):
+    """Generate a unique filename for a given URL."""
+    h = hashlib.md5(url.encode('utf-8')).hexdigest()
+    # Here we assume JPEG. You might want to derive extension from url or headers.
+    return os.path.join(CACHE_DIR, f"{h}.jpg")
 
 # Internal mapping of crops to pests (for the form)
 CROP_TO_PESTS = {
@@ -46,43 +55,14 @@ CROP_MAPPING = {
 
 # Map our internal pest names to external page values per crop.
 PEST_MAPPING = {
-    "Cotton": {
-        "FallArmyWorm": "71"
-    },
-    "Gram": {
-        "H.armigera": "72",
-        "Wilt": "73"
-    },
-    "Maize": {
-        "FallArmyWorm": "74"
-    },
-    "Rice": {
-        "Blast": "75",
-        "GallMidge": "76",
-        "YSB": "77",
-        "PlantHopper": "78",
-        "BlueBeetle": "79",
-        "BacterialLeafBlight": "80"
-    },
-    "Soybean": {
-        "Girdlebeetle": "81",
-        "H.armigera": "82",
-        "Semilooper": "83",
-        "Spodoptera": "84",
-        "StemFLy": "85"
-    },
-    "Tur": {
-        "Wilt": "86",
-        "Webbed_Leaves": "87",
-        "Pod_damage": "88"
-    },
-    "Sugarcane": {
-        "FallArmyGrub": "89",
-        "WhiteGrub": "90"
-    },
-    "Sorgum": {
-        "FallArmyWorm": "91"
-    }
+    "Cotton": {"FallArmyWorm": "71"},
+    "Gram": {"H.armigera": "72", "Wilt": "73"},
+    "Maize": {"FallArmyWorm": "74"},
+    "Rice": {"Blast": "75", "GallMidge": "76", "YSB": "77", "PlantHopper": "78", "BlueBeetle": "79", "BacterialLeafBlight": "80"},
+    "Soybean": {"Girdlebeetle": "81", "H.armigera": "82", "Semilooper": "83", "Spodoptera": "84", "StemFLy": "85"},
+    "Tur": {"Wilt": "86", "Webbed_Leaves": "87", "Pod_damage": "88"},
+    "Sugarcane": {"FallArmyGrub": "89", "WhiteGrub": "90"},
+    "Sorgum": {"FallArmyWorm": "91"}
 }
 
 # Parameter codes and labels for the final image URL
@@ -103,13 +83,13 @@ def index():
     week = request.args.get('week', '')
     param = request.args.get('param', '')
 
-    image_url = ""
+    image_url_param = ""
     if crop and pest and year and week and param:
         # Build the external image URL (using HTTP)
         base_url = f"http://www.icar-crida.res.in:8080/naip/gisimages/{crop}/{year}/{pest}_"
         external_image_url = f"{base_url}{param}{week}.jpg"
-        # Build our proxy URL so that the image is served via our app
-        image_url = f"/fast-proxy?url={external_image_url}"
+        # Instead of proxying on every request, pass the external URL to the template.
+        image_url_param = external_image_url
 
     return render_template('index.html',
                            crops=list(CROP_TO_PESTS.keys()),
@@ -121,8 +101,9 @@ def index():
                            selected_year=year,
                            selected_week=week,
                            selected_param=param,
-                           image_url=image_url)
+                           image_url_param=image_url_param)
 
+# Cache this route based on its query string.
 @app.route('/fetch_weeks')
 @cache.cached(timeout=300, query_string=True)
 def fetch_weeks():
@@ -153,48 +134,27 @@ def fetch_weeks():
         weeks = [str(i) for i in range(1, 53)]
     return jsonify({"weeks": weeks})
 
-# This endpoint now uses a background-prefetched image.
-@app.route('/fast-proxy')
-def fast_proxy():
-    global cached_image, cached_mimetype
-    # If the "url" parameter doesn't match our cached URL, you might consider triggering a prefetch update.
+# New endpoint to serve a locally cached image file.
+@app.route('/cached-image')
+def cached_image_route():
     external_url = request.args.get('url')
-    if cached_image and external_url == prefetch_image.cached_url:
-        return Response(cached_image, mimetype=cached_mimetype)
+    if not external_url:
+        return "Missing URL", 400
+
+    cache_filename = get_cache_filename(external_url)
+    if os.path.exists(cache_filename):
+        return send_file(cache_filename, mimetype="image/jpeg")
     else:
-        # If no pre-fetched image is available, fall back to a direct fetch.
         try:
             resp = requests.get(external_url, timeout=10)
-            return Response(resp.content, mimetype=resp.headers.get('Content-Type', 'image/jpeg'))
+            if resp.status_code == 200:
+                with open(cache_filename, "wb") as f:
+                    f.write(resp.content)
+                return send_file(cache_filename, mimetype=resp.headers.get('Content-Type', 'image/jpeg'))
+            else:
+                return "Error downloading image", resp.status_code
         except Exception as e:
             return str(e), 500
 
-# Background prefetching – we also store the URL that was prefetched.
-def prefetch_image_task():
-    global cached_image, cached_mimetype
-    # For demonstration, we prefetch one specific image.
-    # In a more dynamic scenario, you could maintain a dict of URL -> image data.
-    while True:
-        # Here, update the URL as needed. For example, if you have default parameters:
-        url = "http://www.icar-crida.res.in:8080/naip/gisimages/7/2024-25/74_Maxt1.jpg"
-        try:
-            response = requests.get(url, timeout=10)
-            if response.status_code == 200:
-                cached_image = response.content
-                cached_mimetype = response.headers.get('Content-Type', 'image/jpeg')
-                prefetch_image_task.cached_url = url
-                print("Prefetched image from", url)
-            else:
-                print("Failed to prefetch, status code:", response.status_code)
-        except Exception as ex:
-            print("Prefetch error:", ex)
-        time.sleep(300)  # Update every 5 minutes
-
-# Initialize cached_url attribute for our task function.
-prefetch_image_task.cached_url = ""
-
-# Start the background prefetch thread
-threading.Thread(target=prefetch_image_task, daemon=True).start()
-
 if __name__ == '__main__':
     app.run(debug=True)