tomorrow

app.py

@@ -1,193 +1,128 @@
-# app.py
-# Gradio app: Tomorrow.io hourly (next 24 hours)
-# Requirements: pip install gradio requests pandas python-dateutil python-dotenv
-
 import os
 import requests
 import pandas as pd
 import gradio as gr
+from datetime import datetime, timedelta, timezone
 from zoneinfo import ZoneInfo
-from dotenv import load_dotenv
-import numpy as np
-from html import escape
-
-load_dotenv()
-
-# -------------------
-# Helper functions
-# -------------------
-
-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 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
-
-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"):
-    """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":
-        return f"background: rgba(59, 130, 246, {0.18*pct});"
-    if hue == "green":
-        return f"background: rgba(34, 197, 94, {0.18*pct});"
-    return ""
-
-def build_pretty_table(df: pd.DataFrame) -> str:
-    if df is None or len(df) == 0:
-        return "<p>No data.</p>"
-
-    vmax_pop = max(70, np.nanmax(df["TMRW_RAIN_PROB_%"]))
-    vmax_mm  = max(2.0, np.nanmax(df["TMRW_PrecipRate_mmph"]))
-
-    rows_html = []
-    rows_html.append(
-        "<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>"
-    )
-
-    body = []
-    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>{_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 class='{row_class}'>" + "".join(cells) + "</tr>")
-
-    table_html = f"""
-    <style>
-      .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
-
-
-# -------------------
-# API Configs
-# -------------------
-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
-
-# ---------- 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 []
+
+# --- CONFIG ---
+TOMORROW_API_KEY     = os.getenv("TOMORROW_API_KEY", "teKj9Rkys1UzWxKBEs36pAR8paCXnPW6")
+METEOMATICS_USERNAME = os.getenv("METEO_USERNAME", "ptbukitteknologidigital_tudjuka_ricky")
+METEOMATICS_PASSWORD = os.getenv("METEO_PASSWORD", "u5n25MwaviEG3O3v8q94")
+
+DEFAULT_LAT = 0.46876
+DEFAULT_LON = 116.16879
+LOCAL_TZ = ZoneInfo("Asia/Kuala_Lumpur")  # ✅ changed from Asia/Jakarta to Asia/Kuala_Lumpur
+
+MM_VAR_RAIN = "precip_1h:mm"
+MM_VAR_PROB = "prob_precip_1h:p"
+DEFAULT_MODEL = "ecmwf-ifs"
+
+# --- Tomorrow.io fetch ---
+def fetch_tomorrow(lat, lon, hours=24):
+    if not TOMORROW_API_KEY:
+        raise RuntimeError("Missing TOMORROW_API_KEY")
+
+    url = "https://api.tomorrow.io/v4/weather/forecast"
+    params = {
+        "location": f"{lat},{lon}",
+        "units": "metric",
+        "fields": "rainIntensity,precipitationProbability",
+        "apikey": TOMORROW_API_KEY,
+    }
+    r = requests.get(url, params=params, timeout=25)
+    if r.status_code != 200:
+        raise RuntimeError(f"Tomorrow.io API error: {r.status_code} {r.text}")
+
+    data = r.json().get("timelines", {}).get("hourly", [])
+    if not data:
+        raise RuntimeError("Tomorrow.io: no hourly data returned")
+
     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,
-            "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)
-    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")
-    )
+    for p in data[:hours]:
+        ts = pd.to_datetime(p["time"], utc=True).tz_convert(LOCAL_TZ)
+        vals = p.get("values", {})
+        rain = float(vals.get("rainIntensity", 0.0) or 0.0)
+        prob = float(vals.get("precipitationProbability", 0.0) or 0.0)
+        rows.append({"time": ts, "tio_rain": rain, "tio_prob": prob})
+    return pd.DataFrame(rows)
+
+# --- Meteomatics fetch ---
+def fetch_meteomatics(lat, lon, hours=24):
+    if not METEOMATICS_USERNAME or not METEOMATICS_PASSWORD:
+        raise RuntimeError("Missing METEOMATICS credentials")
+
+    start = datetime.now(timezone.utc).replace(minute=0, second=0, microsecond=0)
+    end   = start + timedelta(hours=hours - 1)
+    timepath = f"{start.isoformat().replace('+00:00','Z')}--{end.isoformat().replace('+00:00','Z')}:PT1H"
+    url = f"https://api.meteomatics.com/{timepath}/{MM_VAR_RAIN},{MM_VAR_PROB}/{lat},{lon}/json"
+    params = {"model": DEFAULT_MODEL}
+
+    r = requests.get(url, auth=(METEOMATICS_USERNAME, METEOMATICS_PASSWORD), params=params, timeout=25)
+    if r.status_code != 200:
+        raise RuntimeError(f"Meteomatics API error: {r.status_code} {r.text}")
+
+    js = r.json().get("data", [])
+    if not js:
+        raise RuntimeError("Meteomatics: no data returned")
+
+    time_map = {}
+    for entry in js:
+        var = entry.get("parameter")
+        for d in entry["coordinates"][0]["dates"]:
+            ts = pd.to_datetime(d["date"], utc=True).tz_convert(LOCAL_TZ)
+            val = float(d.get("value", 0.0) or 0.0)
+            rec = time_map.setdefault(ts, {})
+            if var == MM_VAR_RAIN:
+                rec["mm_rain"] = val
+            elif var == MM_VAR_PROB:
+                rec["mm_prob"] = val
+
+    df = pd.DataFrame([
+        {"time": t, "mm_rain": rec.get("mm_rain", 0.0), "mm_prob": rec.get("mm_prob", 0.0)}
+        for t, rec in sorted(time_map.items())
+    ])
     return df
 
-# ---------- Gradio UI ----------
-with gr.Blocks(fill_height=True) as demo:
-    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("Get Forecast", variant="primary")
+# --- Combine & table ---
+def build_table(lat, lon):
+    df_tio = fetch_tomorrow(lat, lon, 24)
+    df_mm  = fetch_meteomatics(lat, lon, 24)
+    df = pd.merge(df_tio, df_mm, on="time", how="outer").sort_values("time")
+
+    table = pd.DataFrame({
+        "Time (Asia/Kuala_Lumpur)": df["time"].dt.strftime("%Y-%m-%d %H:%M"),
+        "Tomorrow.io Rain (mm/hr)": df["tio_rain"].round(3),
+        "Tomorrow.io Prob (%)": df["tio_prob"].round(1),
+        "Meteomatics Rain (mm/hr)": df["mm_rain"].round(3),
+        "Meteomatics Prob (%)": df["mm_prob"].round(1),
+    })
+    return table
+
+def run_table(lat, lon):
+    try:
+        table = build_table(lat, lon)
+        info = f"<small>Location: {lat:.5f}, {lon:.5f} | Model: <b>{DEFAULT_MODEL}</b> | Timezone: <b>Asia/Kuala_Lumpur</b> | Units: <b>mm/hr</b> | Horizon: 24 hours</small>"
+        return table, info
+    except Exception as e:
+        return None, f"<p><b>Error:</b> {e}</p>"
 
-    out_table = gr.HTML(label="Hourly forecast table")
-    out_info = gr.Markdown()
-    dl_btn = gr.DownloadButton(label="Download CSV", value=None)
+# --- Gradio UI ---
+with gr.Blocks(title="Next 24 Hours — Tomorrow.io + Meteomatics Table (mm/hr)") as demo:
+    gr.Markdown("## 🌧️ Next 24 Hours — **Tomorrow.io** & **Meteomatics** (All in mm/hr)\n"
+                "Side-by-side hourly rain and probability forecasts for the next 24 hours.")
+
+    with gr.Row():
+        lat = gr.Number(label="Latitude", value=DEFAULT_LAT)
+        lon = gr.Number(label="Longitude", value=DEFAULT_LON)
 
-    def _run(loc_s):
-        try:
-            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, f"**Location:** {loc_s} • Rows: {len(df)} • Source: Tomorrow.io", csv_path
-        except Exception as ex:
-            return f"<pre>{escape(str(ex))}</pre>", "", None
+    btn = gr.Button("Fetch 24h Table")
+    table_out = gr.Dataframe(interactive=False, wrap=True)
+    info_out = gr.HTML()
 
-    btn.click(_run, inputs=[loc], outputs=[out_table, out_info, dl_btn])
+    btn.click(run_table, inputs=[lat, lon], outputs=[table_out, info_out])
 
 if __name__ == "__main__":
-    demo.launch()
+    os.environ["GRADIO_ANALYTICS_ENABLED"]="false"
+    os.environ["HF_HUB_DISABLE_TELEMETRY"]="1"
+    demo.launch(server_name="127.0.0.1", server_port=7861, show_error=True, inbrowser=False, debug=True)