add tomorrow

app.py

@@ -1,135 +1,291 @@
 # app.py
-# Gradio app: Xweather hourly forecast table (next 12 hours)
-# Requirements: pip install gradio requests pandas python-dateutil
+# Gradio app: Xweather vs Tomorrow.io hourly (next 24 hours) side-by-side
+# Requirements: pip install gradio requests pandas python-dateutil python-dotenv
 
 import os
 import requests
 import pandas as pd
 import gradio as gr
 from zoneinfo import ZoneInfo
+from dotenv import load_dotenv
+import numpy as np
+from html import escape
 
-BASE_URL = "https://data.api.xweather.com/forecasts/"
+load_dotenv()
 
-CLIENT_ID = "BlZV8kShcnDxJ2ugQ3b65"
-CLIENT_SECRET = "JYvA8vAJJqEO6yP5QixQw59V3oUKqO9HHvj7ZI2R"
+# -------------------
+# Helper functions
+# -------------------
 
-def fetch_hourly_table(location: str):
-    """
-    location: either 'lat,lon' (e.g., '-6.29,106.82') or a place string (e.g., 'Jakarta, ID')
-    returns: (pandas.DataFrame, info_markdown)
-    """
-    if not CLIENT_ID or not CLIENT_SECRET:
-        return None, "❌ Missing API credentials. Please set XWEATHER_CLIENT_ID and XWEATHER_CLIENT_SECRET."
-
-    location = (location or "").strip()
-    if not location:
-        return None, "❌ Enter a location (e.g., '-6.29,106.82' or 'Jakarta, ID')."
-
-    # Build request
-    # {id} may be 'city,cc' or 'lat,lon'. Keep comma unescaped so the API recognizes coordinates.
-    url = BASE_URL + requests.utils.quote(location, safe=",")
-    params = {
-        "client_id": CLIENT_ID,
-        "client_secret": CLIENT_SECRET,
-        "filter": "1hr",  # hourly periods
-        "limit": 24       # next 12 hours
-    }
+def _wx_emoji(txt):
+    """Safely format weather text with emoji icons"""
+    if txt is None or (isinstance(txt, float) and np.isnan(txt)):
+        return "—"
+    txt = str(txt)  # ensure always string
+    t = txt.lower()
+    if "thunder" in t: return "⛈️ " + txt
+    if "shower" in t or "rain" in t or "drizzle" in t: return "🌧️ " + txt
+    if "fog" in t or "mist" in t: return "🌫️ " + txt
+    if "cloud" in t or "overcast" in t: return "☁️ " + txt
+    if "clear" in t or "sun" in t: return "☀️ " + txt
+    return txt
 
-    try:
-        r = requests.get(url, params=params, timeout=20)
-    except requests.RequestException as e:
-        return None, f"❌ Network error: {e}"
-
-    if r.status_code == 404:
-        # Common case: no coverage for that location
-        return None, f"⚠️ No forecast coverage for this location (404). Try a nearby city or adjust coordinates."
-    if r.status_code != 200:
-        # Show a short snippet of the response for debugging
-        body = r.text[:400]
-        return None, f"❌ API error {r.status_code}:\n```\n{body}\n```"
 
+def _fmt(x, nd=1):
+    if x is None or (isinstance(x, float) and np.isnan(x)): return "—"
+    if isinstance(x, (int, np.integer)): return f"{x:d}"
+    if isinstance(x, (float, np.floating)): return f"{x:.{nd}f}"
+    return escape(str(x))
+
+def _heat(value, vmax, hue="blue"):
     try:
-        data = r.json()
-    except ValueError:
-        return None, "❌ Failed to parse JSON response."
-
-    # Xweather returns a top-level list of records for this endpoint
-    # (loc/place/periods/profile per record)
-    # Fallbacks included in case the format changes.
-    records = []
-    if isinstance(data, list):
-        records = data
-    elif isinstance(data, dict) and "response" in data:
-        records = data["response"]
+        v = float(value or 0.0)
+    except:
+        v = 0.0
+    pct = max(0.0, min(1.0, v / max(vmax, 1e-9)))
+    if hue == "blue":
+        return f"background: rgba(0, 123, 255, {0.08*pct});"
+    if hue == "green":
+        return f"background: rgba(0, 200, 83, {0.08*pct});"
+    return ""
+
+def build_pretty_table(df: pd.DataFrame) -> tuple[str, dict]:
+    if df is None or len(df) == 0:
+        return "<p>No data.</p>", {}
+
+    df = df.copy()
+    df["XW_mm"] = pd.to_numeric(df.get("XW_Precip_mm"), errors="coerce")
+    df["TMRW_mm"] = pd.to_numeric(df.get("TMRW_PrecipRate_mmph"), errors="coerce")
+    df["XW_PoP"] = pd.to_numeric(df.get("XW_RAIN_PROB_%"), errors="coerce")
+    df["TMRW_PoP"] = pd.to_numeric(df.get("TMRW_RAIN_PROB_%"), errors="coerce")
+
+    # Rain alert condition
+    rain_flag = (
+        ((df["XW_mm"] >= 1.0) | (df["TMRW_mm"] >= 1.0)) |
+        ((df["XW_PoP"] >= 70) | (df["TMRW_PoP"] >= 70))
+    )
+
+    # Next rain + peak rain
+    def _first_rain_row():
+        for _, row in df.iterrows():
+            if (row.get("XW_mm", 0) >= 1) or (row.get("TMRW_mm", 0) >= 1) or \
+               (row.get("XW_PoP", 0) >= 70) or (row.get("TMRW_PoP", 0) >= 70):
+                return row.get("Local Time")
+        return None
+    next_rain = _first_rain_row()
+
+    xw_vals = df["XW_mm"].fillna(0).to_numpy() if "XW_mm" in df else np.zeros(len(df))
+    tm_vals = df["TMRW_mm"].fillna(0).to_numpy() if "TMRW_mm" in df else np.zeros(len(df))
+    df["peak_proxy"] = np.maximum(xw_vals, tm_vals)
+
+    if df["peak_proxy"].max() > 0:
+        peak_idx = int(df["peak_proxy"].idxmax())
+        peak_when = df.iloc[peak_idx]["Local Time"]
+        peak_amt = float(df.iloc[peak_idx]["peak_proxy"])
     else:
-        records = [data]
+        peak_when, peak_amt = None, 0.0
 
-    if not records or "periods" not in records[0]:
-        return None, "⚠️ Unexpected response format or no periods returned."
+    summary = {
+        "next_rain": next_rain,
+        "peak_when": peak_when,
+        "peak_mmph": round(peak_amt, 1),
+        "has_rain": bool(next_rain),
+    }
 
-    rec = records[0]
-    periods = (rec.get("periods") or [])[:24]
-    if not periods:
-        return None, "⚠️ No hourly periods returned."
+    # --- Grouped header ---
+    rows_html = []
+    rows_html.append(
+        "<thead>"
+        "<tr>"
+        "<th rowspan='2'>Local Time</th>"
+        "<th class='xw-col' colspan='3'>Xweather</th>"
+        "<th class='tm-col' colspan='3'>Tomorrow.io</th>"
+        "</tr>"
+        "<tr>"
+        "<th class='xw-col'>Weather</th>"
+        "<th class='xw-col'>Rain Prob. %</th>"
+        "<th class='xw-col'>Rain mm</th>"
+        "<th class='tm-col'>Weather</th>"
+        "<th class='tm-col'>Rain Prob. %</th>"
+        "<th class='tm-col'>Rain mm/h</th>"
+        "</tr>"
+        "</thead>"
+    )
 
-    # Use location timezone if provided
-    tz_str = (rec.get("profile") or {}).get("tz")
-    tz = None
-    if tz_str:
-        try:
-            tz = ZoneInfo(tz_str)
-        except Exception:
-            tz = None
+    vmax_pop = max(70, np.nanmax([df["XW_PoP"].max(), df["TMRW_PoP"].max()]))
+    vmax_mm  = max(2.0, np.nanmax([df["XW_mm"].max(), df["TMRW_mm"].max()]))
+
+    body = []
+    for i, r in df.iterrows():
+        alert = rain_flag.iloc[i]
+        tr_style = "background: rgba(255,165,0,0.08);" if alert else ""
+        cells = [
+            f"<td>{escape(str(r.get('Local Time','')))}</td>",
+            f"<td class='xw-cell'>{_wx_emoji(r.get('XW_Weather'))}</td>",
+            f"<td class='xw-cell' style='{_heat(r.get('XW_PoP'), vmax_pop, 'green')}'>{_fmt(r.get('XW_PoP'))}</td>",
+            f"<td class='xw-cell' style='{_heat(r.get('XW_mm'), vmax_mm, 'blue')}'>{_fmt(r.get('XW_mm'))}</td>",
+            f"<td class='tm-cell'>{_wx_emoji(r.get('TMRW_Weather'))}</td>",
+            f"<td class='tm-cell' style='{_heat(r.get('TMRW_PoP'), vmax_pop, 'green')}'>{_fmt(r.get('TMRW_PoP'))}</td>",
+            f"<td class='tm-cell' style='{_heat(r.get('TMRW_mm'), vmax_mm, 'blue')}'>{_fmt(r.get('TMRW_mm'))}</td>",
+        ]
+        body.append(f"<tr style='{tr_style}'>" + "".join(cells) + "</tr>")
+
+    table_css = """
+    <style>
+      .wx-table { width: 100%; border-collapse: collapse; font-family: ui-sans-serif, system-ui, -apple-system; }
+      .wx-table th, .wx-table td { padding: 10px 8px; border-bottom: 1px solid #eee; font-size: 14px; vertical-align: middle; text-align: center;}
+      .wx-table thead th { position: sticky; top: 0; z-index: 1; }
+      .wx-table th.xw-col { background: #cfe2ff; text-align: center;}   /* Xweather headers */
+      .wx-table th.tm-col { background: #d4edda; text-align: center;}   /* Tomorrow.io headers */
+      .wx-table th:first-child { background: #fafafa; }
+      .xw-cell { background: #f8fbff; }
+      .tm-cell { background: #f9fff9; }
+      .wx-chips { display:flex; gap:8px; flex-wrap: wrap; margin: 10px 0 6px; }
+      .chip { padding:6px 10px; border-radius: 999px; background: #f5f5f5; border:1px solid #eee; font-size: 13px; }
+      .chip.good { background:#e6f4ea; border-color:#ccebd7; }
+      .chip.warn { background:#fff7e6; border-color:#ffe2b3; }
+    </style>
+    """
+
+    chips = []
+    chips.append(f"<span class='chip {'warn' if summary['has_rain'] else 'good'}'>"
+                 f"{'Next rain: ' + escape(summary['next_rain']) if summary['has_rain'] else 'No rain signal in next 24h'}</span>")
+    if summary["peak_mmph"] > 0:
+        chips.append(f"<span class='chip'>Peak ~{summary['peak_mmph']} mm/h at {escape(summary['peak_when'] or '')}</span>")
+
+    header_html = "<div class='wx-chips'>" + "".join(chips) + "</div>"
 
+    table_html = f"""
+    {table_css}
+    {header_html}
+    <table class="wx-table">
+      {''.join(rows_html)}
+      <tbody>
+        {''.join(body)}
+      </tbody>
+    </table>
+    """
+    return table_html, summary
+
+# -------------------
+# API Configs
+# -------------------
+XW_BASE_URL = "https://data.api.xweather.com/forecasts/"
+CLIENT_ID = os.getenv("XWEATHER_CLIENT_ID") or "BlZV8kShcnDxJ2ugQ3b65"
+CLIENT_SECRET = os.getenv("XWEATHER_CLIENT_SECRET") or "JYvA8vAJJqEO6yP5QixQw59V3oUKqO9HHvj7ZI2R"
+
+TMRW_BASE = "https://api.tomorrow.io/v4/weather/forecast"
+TMRW_API_KEY = os.getenv("TOMORROW_API_KEY") or "teKj9Rkys1UzWxKBEs36pAR8paCXnPW6"
+
+TMRW_WEATHER_CODE = {
+    0: "Unknown", 1000: "Clear", 1100: "Mostly Clear", 1101: "Partly Cloudy", 1102: "Mostly Cloudy",
+    1001: "Cloudy", 2000: "Fog", 2100: "Light Fog",
+    4000: "Drizzle", 4001: "Rain", 4200: "Light Rain", 4201: "Heavy Rain",
+    5000: "Snow", 5001: "Flurries", 5100: "Light Snow", 5101: "Heavy Snow",
+    6000: "Freezing Drizzle", 6001: "Freezing Rain", 6200: "Light Freezing Rain", 6201: "Heavy Freezing Rain",
+    7000: "Ice Pellets", 7101: "Heavy Ice Pellets", 7102: "Light Ice Pellets",
+    8000: "Thunderstorm"
+}
+
+def _safe_to_timestamp(iso: str):
+    if not iso: return None
+    try: return pd.to_datetime(iso)
+    except Exception: return None
+
+# ---------- Xweather ----------
+def fetch_xweather_hourly(location: str, limit: int = 24):
+    url = XW_BASE_URL + requests.utils.quote(location.strip(), safe=",")
+    params = {"client_id": CLIENT_ID, "client_secret": CLIENT_SECRET, "filter": "1hr", "limit": limit}
+    r = requests.get(url, params=params, timeout=20)
+    r.raise_for_status()
+    data = r.json()
+    recs = data.get("response") if isinstance(data, dict) and "response" in data else data
+    rec = recs[0] if isinstance(recs, list) and recs else data
+    periods = rec.get("periods") or []
+    tz_str = (rec.get("profile") or {}).get("tz", "")
     rows = []
-    for p in periods:
-        # Prefer ISO time (already timezone-aware with offset)
+    for p in periods[:limit]:
         iso = p.get("dateTimeISO") or p.get("validTime")
-        dt = pd.to_datetime(iso) if iso else None
-        if tz and getattr(dt, "tzinfo", None) is not None:
-            try:
-                dt = dt.tz_convert(tz)
-            except Exception:
-                pass
-
+        t_utc = _safe_to_timestamp(iso)
+        if isinstance(t_utc, pd.Timestamp) and t_utc.tzinfo:
+            t_utc = t_utc.tz_convert("UTC")
         rows.append({
-            "Time": dt.strftime("%Y-%m-%d %H:%M %Z") if isinstance(dt, pd.Timestamp) else iso,
-            "Weather": p.get("weather") or p.get("weatherPrimary"),
-            "Temp (°C)": p.get("tempC") if p.get("tempC") is not None else p.get("avgTempC"),
-            "Feels (°C)": p.get("feelslikeC") if p.get("feelslikeC") is not None else p.get("avgFeelslikeC"),
-            "Humidity (%)": p.get("humidity"),
-            "POP (%)": p.get("pop"),
-            "Precip (mm)": p.get("precipMM"),
-            "Wind (kph)": p.get("windSpeedKPH"),
-            "Wind Dir": p.get("windDir"),
-            "Visibility (km)": p.get("visibilityKM"),
-            "Cloud Cover (%)": p.get("sky"),
+            "time_utc": t_utc,
+            "XW_Weather": p.get("weather") or p.get("weatherPrimary"),
+            "XW_Humidity_%": p.get("humidity"),
+            "XW_RAIN_PROB_%": p.get("pop"),
+            "XW_Precip_mm": p.get("precipMM"),
+            "XW_Visibility_km": p.get("visibilityKM"),
+            "XW_Cloud_%": p.get("sky"),
+            "XW_TZ": tz_str,
         })
-
     df = pd.DataFrame(rows)
+    df["time_hour_utc"] = pd.to_datetime(df["time_utc"]).dt.tz_convert("UTC").dt.floor("H")
+    return df
 
-    place = rec.get("place") or {}
-    place_str = ", ".join([x for x in [place.get("name"), place.get("state"), place.get("country")] if x])
-    loc_str = f"**Location**: {place_str or location}"
-    tz_info = f" • **Timezone**: {tz_str}" if tz_str else ""
-    meta = f"{loc_str}{tz_info} • Periods: {len(df)} (filter=1hr, limit=24)"
+# ---------- Tomorrow.io ----------
+def fetch_tomorrow_hourly(latlon: str, hours: int = 24):
+    params = {"location": latlon.strip(), "timesteps": "hourly", "units": "metric", "apikey": TMRW_API_KEY}
+    r = requests.get(TMRW_BASE, params=params, timeout=20)
+    r.raise_for_status()
+    data = r.json()
+    hourly = (data.get("timelines") or {}).get("hourly") or []
+    rows = []
+    for h in hourly[:hours]:
+        t_utc = _safe_to_timestamp(h.get("time"))
+        v = h.get("values") or {}
+        code = v.get("weatherCode")
+        rows.append({
+            "time_utc": t_utc.tz_convert("UTC") if isinstance(t_utc, pd.Timestamp) and t_utc.tzinfo else t_utc,
+            "TMRW_Weather": TMRW_WEATHER_CODE.get(code, str(code) if code is not None else None),
+            "TMRW_Humidity_%": v.get("humidity"),
+            "TMRW_RAIN_PROB_%": v.get("precipitationProbability"),
+            "TMRW_PrecipRate_mmph": v.get("rainIntensity"),
+            "TMRW_Visibility_km": v.get("visibility"),
+            "TMRW_Cloud_%": v.get("cloudCover"),
+        })
+    df = pd.DataFrame(rows)
+    df["time_hour_utc"] = pd.to_datetime(df["time_utc"]).dt.tz_convert("UTC").dt.floor("H")
+    return df
 
-    return df, meta
+# ---------- Merge ----------
+def build_side_by_side(location: str):
+    xw = fetch_xweather_hourly(location, limit=24)
+    tm = fetch_tomorrow_hourly(location, hours=24)
+    merged = pd.merge(xw, tm, on="time_hour_utc", how="outer", sort=True)
+    try:
+        local_tz = ZoneInfo("Asia/Singapore")  # UTC+8
+        merged["Local Time"] = (
+            pd.to_datetime(merged["time_hour_utc"])
+            .dt.tz_convert(local_tz)   # ✅ directly convert from UTC
+            .dt.strftime("%Y-%m-%d %H:%M %Z")
+        )
+    except Exception:
+        merged["Local Time"] = merged["time_hour_utc"].astype(str)
+    return merged, f"**Location:** {location} • Rows: {len(merged)} • Sources: Xweather + Tomorrow.io (UTC+8)"
 
+# ---------- Gradio UI ----------
 with gr.Blocks(fill_height=True) as demo:
-    gr.Markdown("## Xweather — Hourly Forecast (Next 24 Hours)")
+    gr.Markdown("## Hourly Forecast — Side by Side (Xweather vs Tomorrow.io)")
     with gr.Row():
-        loc = gr.Textbox(
-            label="Location",
-            placeholder="lat,lon (e.g., -6.21,106.85) or place name (e.g., 'Jakarta, ID')",
-            value="0.46876,116.16879"
-        )
-        btn = gr.Button("Get forecast", variant="primary")
-    out_table = gr.Dataframe(label="Hourly forecast", interactive=False, wrap=True)
+        loc = gr.Textbox(label="Location (lat,lon)", placeholder="e.g., -6.21,106.85", value="0.46876,116.16879")
+        btn = gr.Button("Compare", variant="primary")
+
+    out_table = gr.HTML(label="Hourly comparison (next 24h)")
     out_info = gr.Markdown()
+    dl_btn = gr.DownloadButton(label="Download CSV", value=None)
+
+    def _run(loc_s):
+        try:
+            df, meta = build_side_by_side(loc_s)
+            html, summary = build_pretty_table(df)
+            csv_path = "forecast_compare.csv"
+            df.to_csv(csv_path, index=False)
+            return html, meta, csv_path
+        except Exception as ex:
+            return f"<pre>{escape(str(ex))}</pre>", "", None
 
-    btn.click(fetch_hourly_table, inputs=loc, outputs=[out_table, out_info])
+    btn.click(_run, inputs=[loc], outputs=[out_table, out_info, dl_btn])
 
 if __name__ == "__main__":
-    # For local runs; on Spaces, Gradio will call this file directly.
     demo.launch()