Update app.py

app.py

@@ -2,6 +2,7 @@ from flask import Flask, render_template, request, jsonify, Response
 import requests
 from bs4 import BeautifulSoup
 from flask import stream_with_context
+from concurrent.futures import ThreadPoolExecutor, as_completed
 
 app = Flask(__name__)
 
@@ -93,20 +94,27 @@ def build_image_url(crop, year, pest, param, week):
 def image_exists(url):
     """Return True if the remote image URL returns a valid image (HTTP 200 + image content-type)."""
     try:
-        resp = requests.head(url, timeout=6, allow_redirects=True)
+        resp = requests.head(url, timeout=4, allow_redirects=True)
         if resp.status_code == 200:
-            ct = resp.headers.get("Content-Type", "")
-            return ct.startswith("image/")
-        # Some servers don't support HEAD; fall back to a small GET
+            return resp.headers.get("Content-Type", "").startswith("image/")
+        # Some servers don't support HEAD — fall back to a streaming GET
         if resp.status_code in (405, 403):
-            resp = requests.get(url, timeout=8, stream=True)
-            ct = resp.headers.get("Content-Type", "")
-            return resp.status_code == 200 and ct.startswith("image/")
+            resp = requests.get(url, timeout=4, stream=True)
+            resp.close()
+            return resp.status_code == 200 and resp.headers.get("Content-Type", "").startswith("image/")
     except Exception:
         pass
     return False
 
 
+def week_has_any_data(week, crop, year, pest):
+    """Return week string if any param image exists for it, else None."""
+    for param_code in PARAMS:
+        if image_exists(build_image_url(crop, year, pest, param_code, week)):
+            return week
+    return None
+
+
 @app.route('/')
 def index():
     crop = request.args.get('crop', '')
@@ -141,7 +149,10 @@ def index():
 
 @app.route('/fetch_weeks')
 def fetch_weeks():
-    """Return only weeks for which at least one param image actually exists."""
+    """
+    Return weeks that have at least one available param image.
+    Checks are run in parallel to stay well within the gunicorn timeout.
+    """
     crop = request.args.get('crop', '')
     pest = request.args.get('pest', '')
     year = request.args.get('year', '')
@@ -152,36 +163,40 @@ def fetch_weeks():
     ext_crop = CROP_MAPPING.get(crop, '')
     ext_pest = PEST_MAPPING.get(crop, {}).get(pest, '')
 
-    # Try to scrape available weeks from the upstream page first
+    # Step 1: scrape candidate weeks from upstream (fast — single request)
     candidate_weeks = []
     try:
         payload = {"country": ext_crop, "city": ext_pest, "sowing": year}
-        response = requests.get(
+        resp = requests.get(
             "http://www.icar-crida.res.in:8080/naip/gismaps.jsp",
-            params=payload, timeout=10
+            params=payload, timeout=8
         )
-        soup = BeautifulSoup(response.text, 'html.parser')
-        week_options = soup.select('select[name="week"] option')
+        soup = BeautifulSoup(resp.text, 'html.parser')
         candidate_weeks = [
-            opt.get('value') for opt in week_options
+            opt.get('value') for opt in soup.select('select[name="week"] option')
             if opt.get('value') and "Select" not in opt.get('value', '')
         ]
     except Exception:
         pass
 
-    # Fall back to weeks 1-52 if scraping failed
     if not candidate_weeks:
         candidate_weeks = [str(i) for i in range(1, 53)]
 
-    # Filter: keep only weeks where at least one param image exists
+    # Step 2: check all candidate weeks in parallel (max 20 threads, 4s per request)
     available_weeks = []
-    for week in candidate_weeks:
-        for param_code in PARAMS.keys():
-            url = build_image_url(crop, year, pest, param_code, week)
-            if image_exists(url):
-                available_weeks.append(week)
-                break  # No need to check all params for this week
-
+    with ThreadPoolExecutor(max_workers=20) as executor:
+        futures = {
+            executor.submit(week_has_any_data, week, crop, year, pest): week
+            for week in candidate_weeks
+        }
+        found = set()
+        for future in as_completed(futures):
+            result = future.result()
+            if result is not None:
+                found.add(result)
+
+    # Preserve original order
+    available_weeks = [w for w in candidate_weeks if w in found]
     return jsonify({"weeks": available_weeks})
 
 
@@ -189,7 +204,8 @@ def fetch_weeks():
 def check_availability():
     """
     Check which params are available for a given crop/pest/year/week combination.
-    Returns a dict of {param_code: bool} so the frontend can disable unavailable options.
+    All 5 param checks run in parallel.
+    Returns a dict of {param_code: bool}.
     """
     crop = request.args.get('crop', '')
     pest = request.args.get('pest', '')
@@ -199,10 +215,14 @@ def check_availability():
     if not (crop and pest and year and week):
         return jsonify({"availability": {}})
 
-    availability = {}
-    for param_code in PARAMS.keys():
+    def check_param(param_code):
         url = build_image_url(crop, year, pest, param_code, week)
-        availability[param_code] = image_exists(url)
+        return param_code, image_exists(url)
+
+    availability = {}
+    with ThreadPoolExecutor(max_workers=5) as executor:
+        for param_code, exists in executor.map(lambda p: check_param(p), PARAMS.keys()):
+            availability[param_code] = exists
 
     return jsonify({"availability": availability})