flights: parallelize the 3 provider fetches per search (~3x faster; fixes slow return leg)

app/flights_provider.py

@@ -24,6 +24,7 @@ Environment (never hardcoded):
 """
 
 import os
+from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime, date as _date, timedelta
 from typing import List, Optional, Dict
 
@@ -250,13 +251,23 @@ def _search_once(src, dst, date, nonstop, airlines, max_price,
     # search_by_price_range is one-way only; use it just for one-way sweeps.
     if not return_date:
         fetchers.insert(1, lambda: _fetch_price_range(src, dst, date, nonstop, max_results, max_price))
-    for fetch in fetchers:
+    # The three endpoints are INDEPENDENT Travelpayouts I/O calls. Running them
+    # one after another made a single search ~3x slower than the slowest call -
+    # and on a round trip, where the return leg is searched alongside the
+    # outbound, that extra latency is exactly why "the departure came but the
+    # return didn't load, it takes time". Fan them out on threads and gather;
+    # each still fails independently (a rate-limited/empty endpoint returns []),
+    # and ThreadPoolExecutor.map preserves order, so dedupe/rank are unchanged.
+    def _safe(fetch):
         try:
-            raw.extend(fetch())
+            return fetch()
         except Exception:
             # a single endpoint failing (rate limit, empty cache) must not sink
             # the whole search; we still return whatever the others gave.
-            continue
+            return []
+    with ThreadPoolExecutor(max_workers=len(fetchers)) as ex:
+        for part in ex.map(_safe, fetchers):
+            raw.extend(part)
 
     flights = [_normalize(r, date) for r in raw if r.get("price")]
     flights = _dedupe(flights)