tomorrow

app.py

@@ -1,5 +1,5 @@
 # app.py
-# Gradio app: Xweather vs Tomorrow.io hourly (next 24 hours) side-by-side
+# Gradio app: Tomorrow.io hourly (next 24 hours)
 # Requirements: pip install gradio requests pandas python-dateutil python-dotenv
 
 import os
@@ -37,178 +37,86 @@ def _fmt(x, nd=1):
     return escape(str(x))
 
 def _heat(value, vmax, hue="blue"):
-    """Inline, subtle heat-tint that works in light/dark."""
+    """Inline, subtle heat-tint"""
     try:
         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":
-        # blue overlay
         return f"background: rgba(59, 130, 246, {0.18*pct});"
     if hue == "green":
-        # green overlay
         return f"background: rgba(34, 197, 94, {0.18*pct});"
     return ""
 
-def build_pretty_table(df: pd.DataFrame) -> tuple[str, dict]:
+def build_pretty_table(df: pd.DataFrame) -> str:
     if df is None or len(df) == 0:
-        return "<p>No data.</p>", {}
+        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")
+    vmax_pop = max(70, np.nanmax(df["TMRW_RAIN_PROB_%"]))
+    vmax_mm  = max(2.0, np.nanmax(df["TMRW_PrecipRate_mmph"]))
 
-    # Rain alert rows
-    rain_flag = (
-        ((df["XW_mm"] >= 1.0) | (df["TMRW_mm"] >= 1.0)) |
-        ((df["XW_PoP"] >= 70) | (df["TMRW_PoP"] >= 70))
-    )
-
-    # Next rain (either provider hits threshold first)
-    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()
-
-    # Peak rain (max of providers)
-    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:
-        peak_when, peak_amt = None, 0.0
-
-    summary = {
-        "next_rain": next_rain,
-        "peak_when": peak_when,
-        "peak_mmph": round(peak_amt, 1),
-        "has_rain": bool(next_rain),
-    }
-
-    # --- Grouped headers (2 rows) ---
     rows_html = []
     rows_html.append(
-        "<thead>"
-        "<tr>"
-        "<th rowspan='2' class='local-col'>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>"
+        "<thead><tr>"
+        "<th>Local Time</th>"
+        "<th>Weather</th>"
+        "<th>Rain Prob. %</th>"
+        "<th>Rain mm/h</th>"
+        "<th>Humidity %</th>"
+        "<th>Visibility km</th>"
+        "<th>Cloud %</th>"
+        "</tr></thead>"
     )
 
-    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: var(--alert-bg);" if alert else ""
+    for _, r in df.iterrows():
+        prob = r.get("TMRW_RAIN_PROB_%") or 0
+        rain = r.get("TMRW_PrecipRate_mmph") or 0
+
+        # ✅ Apply green highlight rule
+        row_class = ""
+        try:
+            if (rain >= 1) or (prob > 50 and rain >= 1):
+                row_class = "highlight-green"
+        except Exception:
+            row_class = ""
+
         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>",
+            f"<td>{_wx_emoji(r.get('TMRW_Weather'))}</td>",
+            f"<td style='{_heat(prob, vmax_pop, 'green')}'>{_fmt(prob)}</td>",
+            f"<td style='{_heat(rain, vmax_mm, 'blue')}'>{_fmt(rain)}</td>",
+            f"<td>{_fmt(r.get('TMRW_Humidity_%'))}</td>",
+            f"<td>{_fmt(r.get('TMRW_Visibility_km'))}</td>",
+            f"<td>{_fmt(r.get('TMRW_Cloud_%'))}</td>",
         ]
-        body.append(f"<tr style='{tr_style}'>" + "".join(cells) + "</tr>")
+        body.append(f"<tr class='{row_class}'>" + "".join(cells) + "</tr>")
 
-    # --- Adaptive (light/dark) CSS using CSS variables ---
-    table_css = """
+    table_html = f"""
     <style>
-      :root {
-        --bg: #ffffff;
-        --fg: #111111;
-        --muted: #fafafa;
-        --border: #e5e7eb;
-        --xw-head: #cfe2ff;   /* header blue */
-        --tm-head: #d4edda;   /* header green */
-        --xw-cell: #f8fbff;   /* body blue tint */
-        --tm-cell: #f9fff9;   /* body green tint */
-        --alert-bg: rgba(255, 193, 7, 0.12); /* amber */
-      }
-      @media (prefers-color-scheme: dark) {
-        :root {
-          --bg: #0b1220;
-          --fg: #e5e7eb;
-          --muted: #131c2b;
-          --border: #243042;
-          --xw-head: #10335f;
-          --tm-head: #0f3b26;
-          --xw-cell: #0f213e;
-          --tm-cell: #0f2a1a;
-          --alert-bg: rgba(255, 193, 7, 0.18);
-        }
-      }
-
-      .wx-scope { color: var(--fg); background: transparent; }
-      .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 var(--border);
-        font-size: 14px; vertical-align: middle; text-align: center; color: var(--fg);
-      }
-      .wx-table thead th { position: sticky; top: 0; z-index: 1; }
-      .wx-table th.local-col { background: var(--muted); }
-      .wx-table th.xw-col   { background: var(--xw-head); }
-      .wx-table th.tm-col   { background: var(--tm-head); }
-      .xw-cell { background: var(--xw-cell); }
-      .tm-cell { background: var(--tm-cell); }
-
-      .wx-chips { display:flex; gap:8px; flex-wrap: wrap; margin: 10px 0 6px; }
-      .chip { padding:6px 10px; border-radius: 999px; background: var(--muted); border:1px solid var(--border); font-size: 13px; color: var(--fg); }
-      .chip.good { box-shadow: inset 0 0 0 9999px rgba(34,197,94,0.12); }
-      .chip.warn { box-shadow: inset 0 0 0 9999px rgba(255,193,7,0.12); }
+      .wx-table {{ width: 100%; border-collapse: collapse; font-family: ui-sans-serif, system-ui; }}
+      .wx-table th, .wx-table td {{
+        padding: 8px; border-bottom: 1px solid #ccc; text-align: center;
+      }}
+      /* ✅ Full-row green highlight */
+      tr.highlight-green td {{
+        background: rgba(34,197,94,0.35) !important;
+      }}
     </style>
+    <table class="wx-table">
+      {''.join(rows_html)}
+      <tbody>
+        {''.join(body)}
+      </tbody>
+    </table>
     """
+    return table_html
 
-    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}
-    <div class="wx-scope">
-      {header_html}
-      <table class="wx-table">
-        {''.join(rows_html)}
-        <tbody>
-          {''.join(body)}
-        </tbody>
-      </table>
-    </div>
-    """
-    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"
 
@@ -228,37 +136,6 @@ def _safe_to_timestamp(iso: str):
     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[:limit]:
-        iso = p.get("dateTimeISO") or p.get("validTime")
-        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_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
-
 # ---------- Tomorrow.io ----------
 def fetch_tomorrow_hourly(latlon: str, hours: int = 24):
     params = {"location": latlon.strip(), "timesteps": "hourly", "units": "metric", "apikey": TMRW_API_KEY}
@@ -272,52 +149,41 @@ def fetch_tomorrow_hourly(latlon: str, hours: int = 24):
         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,
+            "time_utc": 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"),  # ✅ correct field
+            "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")
+    local_tz = ZoneInfo("Asia/Singapore")
+    df["Local Time"] = (
+        pd.to_datetime(df["time_utc"])
+        .dt.tz_convert(local_tz)
+        .dt.strftime("%Y-%m-%d %H:%M %Z")
+    )
     return df
 
-# ---------- 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)
-            .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("## Hourly Forecast — Side by Side (Xweather vs Tomorrow.io)")
+    gr.Markdown("## Tomorrow.io Hourly Forecast (Next 24h)")
     with gr.Row():
         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")
+        btn = gr.Button("Get Forecast", variant="primary")
 
-    out_table = gr.HTML(label="Hourly comparison (next 24h)")
+    out_table = gr.HTML(label="Hourly forecast table")
     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 = fetch_tomorrow_hourly(loc_s, hours=24)
+            html = build_pretty_table(df)
+            csv_path = "forecast_tomorrow.csv"
             df.to_csv(csv_path, index=False)
-            return html, meta, csv_path
+            return html, f"**Location:** {loc_s} • Rows: {len(df)} • Source: Tomorrow.io", csv_path
         except Exception as ex:
             return f"<pre>{escape(str(ex))}</pre>", "", None