Hotels: stay totals, not nightly rates

app/hotel_sellers.py

@@ -35,6 +35,7 @@ import json
 import os
 import re
 import time
+from datetime import datetime
 from typing import Dict, List, Optional, Tuple
 
 SERPAPI_URL = "https://serpapi.com/search"
@@ -139,6 +140,17 @@ def _get(params: Dict) -> Dict:
         return r.json()
 
 
+def _nights(checkin: str, checkout: str) -> Optional[int]:
+    """Nights in the stay, or None when the dates are unusable."""
+    try:
+        a = datetime.strptime(checkin, "%Y-%m-%d").date()
+        b = datetime.strptime(checkout, "%Y-%m-%d").date()
+    except (ValueError, TypeError):
+        return None
+    n = (b - a).days
+    return n if n > 0 else None
+
+
 def _amount(block: Optional[Dict]) -> Optional[float]:
     """Google returns {'lowest': '₹19,382', 'extracted_lowest': 19382}."""
     if not isinstance(block, dict):
@@ -152,6 +164,47 @@ def _amount(block: Optional[Dict]) -> Optional[float]:
         return None
 
 
+def _amount_taxed(block: Optional[Dict]) -> Tuple[Optional[float], bool]:
+    """Same figure, plus whether it INCLUDES taxes and fees.
+
+    extracted_lowest is the with-tax figure; extracted_before_taxes_fees is
+    not. Returning them through one function meant a before-tax quote and a
+    with-tax quote were compared as equals in the same min(), quietly
+    favouring whichever vendor happened to omit its taxes.
+    """
+    if not isinstance(block, dict):
+        return None, False
+    v = block.get("extracted_lowest")
+    if v is not None:
+        try:
+            return float(v), True
+        except (TypeError, ValueError):
+            return None, False
+    v = block.get("extracted_before_taxes_fees")
+    try:
+        return (float(v), False) if v is not None else (None, False)
+    except (TypeError, ValueError):
+        return None, False
+
+
+def _stay_total(total: Optional[float], night: Optional[float], nights: Optional[int]):
+    """The STAY TOTAL, and whether we had to derive it.
+
+    NEVER substitutes a per-NIGHT rate for a stay total. That substitution was
+    a silent 5x error on a five-night stay: the field is documented as the
+    total, channel_prices takes min() across vendors, so the ONE vendor that
+    omitted total_rate became "cheapest" by a factor of the night count - and
+    that figure then became the base every offer minimum and cap was judged
+    against. When total_rate is missing we multiply out instead, and say so;
+    when we cannot even do that, the caller drops the row.
+    """
+    if total is not None:
+        return total, False
+    if night is not None and nights:
+        return round(night * nights, 2), True
+    return None, False
+
+
 def _is_direct(source: str, hotel_name: str) -> bool:
     """Google lists the hotel's own site under the property's name (and the
     occasional 'Official site'). Treat that as booking direct."""
@@ -178,15 +231,19 @@ def search_hotels(
         return [], f"serpapi error ({data['error']})"
 
     out: List[Dict] = []
+    nights = _nights(checkin, checkout)
     for p in (data.get("properties") or []):
         total = _amount(p.get("total_rate"))
         night = _amount(p.get("rate_per_night"))
-        if total is None and night is None:
-            continue
+        stay, derived = _stay_total(total, night, nights)
+        if stay is None:
+            continue          # neither a total nor enough to derive one
         out.append({
             # price_inr is the STAY TOTAL, which is what the card is charged and
             # therefore what any offer minimum or cap must be judged against.
-            "price_inr": total if total is not None else night,
+            # A per-night rate is multiplied out, never substituted.
+            "price_inr": stay,
+            "total_derived": derived,
             "nightly_inr": night,
             "currency": "INR",
             "name": p.get("name") or "",
@@ -240,39 +297,54 @@ def sellers_for(
         return dict(empty, source=f"serpapi error ({data['error']})")
 
     hotel_name = data.get("name") or ""
+    nights = _nights(checkin, checkout)
     rows: List[Dict] = []
     for pr in (data.get("prices") or []):
         src = pr.get("source") or ""
-        total = _amount(pr.get("total_rate"))
-        night = _amount(pr.get("rate_per_night"))
-        if not src or (total is None and night is None):
+        total, total_taxed = _amount_taxed(pr.get("total_rate"))
+        night, night_taxed = _amount_taxed(pr.get("rate_per_night"))
+        stay, derived = _stay_total(total, night, nights)
+        if not src or stay is None:
             continue
         key = "direct" if _is_direct(src, hotel_name) else channel_for_vendor(src)
         rows.append({
             "seller": src,
             "channel_key": key,                 # None => a vendor outside our set
-            "price_inr": total if total is not None else night,
+            "price_inr": stay,
+            "total_derived": derived,           # multiplied out from the nightly rate
+            "taxes_included": total_taxed if total is not None else night_taxed,
             "nightly_inr": night,
             "book_url": pr.get("link") or None,
         })
     if not rows:
         return dict(empty, source="serpapi (no vendor prices)")
 
+    # COMPARE LIKE WITH LIKE. A with-tax quote and a before-tax quote are not
+    # the same number, so a channel is priced from its tax-inclusive rows when
+    # it has any, and only falls back to before-tax when that is all it has -
+    # otherwise the vendor that omits its taxes wins on a technicality.
     channel_prices: Dict[str, float] = {}
-    for r in rows:
-        k = r["channel_key"]
-        if not k:
-            continue
-        cur = channel_prices.get(k)
-        if cur is None or r["price_inr"] < cur:
-            channel_prices[k] = r["price_inr"]
+    for taxed_only in (True, False):
+        for r in rows:
+            k = r["channel_key"]
+            if not k or (taxed_only and not r["taxes_included"]):
+                continue
+            if taxed_only or k not in channel_prices:
+                cur = channel_prices.get(k)
+                if cur is None or r["price_inr"] < cur:
+                    channel_prices[k] = r["price_inr"]
 
     payload = {
         "live": True,
         "source": "serpapi",
         "sellers": rows,
         "channel_prices": channel_prices,
-        "priced_total_inr": min((r["price_inr"] for r in rows), default=None),
+        # Same like-with-like rule as channel_prices: the headline "cheapest"
+        # must not be a before-tax quote beating with-tax ones.
+        "priced_total_inr": min(
+            (r["price_inr"] for r in rows if r["taxes_included"]),
+            default=min((r["price_inr"] for r in rows), default=None),
+        ),
     }
     cache[ck] = {"at": time.time(), "payload": payload}
     _cache_save(cache)

app/hotels_provider.py

@@ -36,6 +36,7 @@ Environment (never hardcoded):
 import os
 import json
 import time
+from datetime import datetime
 from typing import List, Optional, Dict, Tuple
 from urllib.parse import quote
 
@@ -129,15 +130,40 @@ def _vendor_label(platform: str) -> str:
     return _VENDOR_LABEL.get((platform or "").lower(), (platform or "OTA").title())
 
 
-def _price_of(prop: Dict) -> float:
+def _price_of(prop: Dict, nights: Optional[int] = None) -> float:
+    """The STAY TOTAL for this property.
+
+    nightlyPrice used to be accepted as a total whenever totalPrice was
+    missing, which understated that property by the night count and let it win
+    a cheapest-vendor comparison it should have lost - the same substitution
+    fixed in hotel_sellers._stay_total. A nightly figure is now multiplied out
+    by the stay length; with no usable dates it is refused rather than passed
+    off as a total.
+    """
     p = prop.get("price") or {}
-    for k in ("totalPrice", "nightlyPrice", "price"):
-        v = p.get(k)
-        if isinstance(v, (int, float)) and v > 0:
-            return float(v)
+    v = p.get("totalPrice")
+    if isinstance(v, (int, float)) and v > 0:
+        return float(v)
+    v = p.get("nightlyPrice")
+    if isinstance(v, (int, float)) and v > 0:
+        return round(float(v) * nights, 2) if nights else 0.0
+    # "price" is unlabelled; trust it only as a last resort, as a total.
+    v = p.get("price")
+    if isinstance(v, (int, float)) and v > 0:
+        return float(v)
     return 0.0
 
 
+def _nights_between(checkin: str, checkout: str) -> Optional[int]:
+    try:
+        a = datetime.strptime(checkin, "%Y-%m-%d").date()
+        b = datetime.strptime(checkout, "%Y-%m-%d").date()
+    except (ValueError, TypeError):
+        return None
+    n = (b - a).days
+    return n if n > 0 else None
+
+
 def _rating5(prop: Dict) -> float:
     """Normalize guestRating to a 0-5 scale (StayingAPI uses ratingScale, often 10)."""
     r = prop.get("guestRating")
@@ -150,10 +176,10 @@ def _rating5(prop: Dict) -> float:
         return 0.0
 
 
-def _normalize(prop: Dict, fallback_city: str) -> Optional[Dict]:
+def _normalize(prop: Dict, fallback_city: str, nights: Optional[int] = None) -> Optional[Dict]:
     if not isinstance(prop, dict) or not prop.get("name"):
         return None
-    price = _price_of(prop)
+    price = _price_of(prop, nights)
     if price <= 0:
         return None  # dated price is best-effort; can't score without one
     loc = prop.get("location") or {}
@@ -266,7 +292,7 @@ def search_hotels(
     # 1) fresh completed result cached -> instant
     hit = cache["search"].get(skey)
     if hit and (time.time() - hit.get("at", 0)) < ttl:
-        return _finish(hit.get("data") or [], city, max_results, "stayingapi (cached)")
+        return _finish(hit.get("data") or [], city, max_results, "stayingapi (cached)", checkin, checkout)
 
     # 2) a job is already in flight for this exact search -> resume it (no new credits)
     job = cache["jobs"].get(skey)
@@ -285,7 +311,7 @@ def search_hotels(
         cache["search"][skey] = {"at": time.time(), "data": payload or []}
         cache["jobs"].pop(skey, None)
         _save_cache(cache)
-        return _finish(payload or [], city, max_results, "stayingapi")
+        return _finish(payload or [], city, max_results, "stayingapi", checkin, checkout)
     if state == "pending":
         # still scraping; the jobId is saved so the next call resumes the same job
         return _mock_hotels(city, checkin, checkout, adults), "sample (stayingapi still scraping - retry shortly)"
@@ -295,8 +321,12 @@ def search_hotels(
     return _mock_hotels(city, checkin, checkout, adults), f"sample (stayingapi {payload})"
 
 
-def _finish(props: List[Dict], city: str, max_results: int, source: str) -> Tuple[List[Dict], str]:
-    hotels = [h for h in (_normalize(p, city) for p in props) if h]
+def _finish(props: List[Dict], city: str, max_results: int, source: str,
+            checkin: str = "", checkout: str = "") -> Tuple[List[Dict], str]:
+    # The stay length, so a nightly-only quote can be multiplied out instead of
+    # masquerading as a total.
+    nights = _nights_between(checkin, checkout)
+    hotels = [h for h in (_normalize(p, city, nights) for p in props) if h]
     hotels.sort(key=lambda h: h["price_inr"])
     if not hotels:
         return _mock_hotels(city, "", "", 2), "sample (stayingapi empty)"