Update app.py

app.py

@@ -1,105 +1,107 @@
 import io
+import sys
+import traceback
 import requests
 import pandas as pd
+
+# Use a headless backend for Spaces/servers (prevents runtime errors)
+import matplotlib
+matplotlib.use("Agg")
 import matplotlib.pyplot as plt
-import datetime
+
 import gradio as gr
 
 GEOCODE_URL = "https://geocoding-api.open-meteo.com/v1/search"
 FORECAST_URL = "https://api.open-meteo.com/v1/forecast"
 
 
-def geocode_city(city_name):
-    params = {"name": city_name, "count": 1, "language": "en"}
-    r = requests.get(GEOCODE_URL, params=params, timeout=10)
+def geocode_city(city_name: str) -> dict:
+    if not city_name or not city_name.strip():
+        raise ValueError("Please enter a city name.")
+
+    params = {"name": city_name.strip(), "count": 1, "language": "en"}
+    r = requests.get(GEOCODE_URL, params=params, timeout=15)
     r.raise_for_status()
     data = r.json()
-    if "results" not in data or len(data["results"]) == 0:
+    if not data.get("results"):
         raise ValueError(f"Location not found: '{city_name}'")
     res = data["results"][0]
     return {
-        "name": res.get("name"),
-        "country": res.get("country"),
-        "latitude": res["latitude"],
-        "longitude": res["longitude"],
-        "timezone": res.get("timezone", "UTC"),
+        "name": res.get("name", city_name),
+        "country": res.get("country", ""),
+        "latitude": float(res["latitude"]),
+        "longitude": float(res["longitude"]),
+        "timezone": res.get("timezone", "auto"),
     }
 
 
-def fetch_forecast(lat, lon, days, forecast_type, temp_unit, precip_unit, timezone):
+def fetch_forecast(lat: float, lon: float, days: int, mode: str, temp_unit: str, precip_unit: str) -> dict:
     params = {
         "latitude": lat,
         "longitude": lon,
-        "timezone": "auto",  # ask API to return local times automatically
+        "timezone": "auto",
         "forecast_days": int(days),
-        # Use sensible hourly/daily params depending on forecast_type
+        "temperature_unit": "fahrenheit" if temp_unit == "°F" else "celsius",
+        "precipitation_unit": "inch" if precip_unit == "in" else "mm",
+        "past_days": 0,
     }
 
-    if forecast_type == "Daily":
-        params["daily"] = ",".join(
-            [
-                "temperature_2m_max",
-                "temperature_2m_min",
-                "precipitation_sum",
-                "sunrise",
-                "sunset",
-            ]
-        )
+    if mode == "Daily":
+        params["daily"] = ",".join([
+            "temperature_2m_max",
+            "temperature_2m_min",
+            "precipitation_sum",
+            "sunrise",
+            "sunset",
+        ])
     else:  # Hourly
-        params["hourly"] = ",".join(
-            [
-                "temperature_2m",
-                "relativehumidity_2m",
-                "apparent_temperature",
-                "precipitation",
-                "windspeed_10m",
-            ]
-        )
-
-    # unit settings supported by Open-Meteo
-    params["temperature_unit"] = "fahrenheit" if temp_unit == "°F" else "celsius"
-    params["precipitation_unit"] = "inch" if precip_unit == "in" else "mm"
-
-    r = requests.get(FORECAST_URL, params=params, timeout=10)
+        params["hourly"] = ",".join([
+            "temperature_2m",
+            "apparent_temperature",
+            "relativehumidity_2m",
+            "precipitation",
+            "windspeed_10m",
+        ])
+
+    r = requests.get(FORECAST_URL, params=params, timeout=20)
     r.raise_for_status()
     return r.json()
 
 
-def build_daily_df(daily):
-    df = pd.DataFrame(
-        {
-            "date": daily["time"],
-            "temp_max": daily.get("temperature_2m_max"),
-            "temp_min": daily.get("temperature_2m_min"),
-            "precipitation": daily.get("precipitation_sum"),
-            "sunrise": daily.get("sunrise"),
-            "sunset": daily.get("sunset"),
-        }
-    )
-    df["date"] = pd.to_datetime(df["date"]).dt.date
+def df_daily(payload: dict) -> pd.DataFrame:
+    d = payload["daily"]
+    df = pd.DataFrame({
+        "date": pd.to_datetime(d["time"]).date,
+        "temp_max": d.get("temperature_2m_max"),
+        "temp_min": d.get("temperature_2m_min"),
+        "precip_total": d.get("precipitation_sum"),
+        "sunrise": pd.to_datetime(d.get("sunrise")),
+        "sunset": pd.to_datetime(d.get("sunset")),
+    })
     return df
 
 
-def build_hourly_df(hourly, days):
-    times = pd.to_datetime(hourly["time"])
-    limit = int(days) * 24
-    df = pd.DataFrame(
-        {
-            "time": times,
-            "temperature": hourly.get("temperature_2m"),
-            "apparent_temperature": hourly.get("apparent_temperature"),
-            "humidity": hourly.get("relativehumidity_2m"),
-            "precipitation": hourly.get("precipitation"),
-            "wind_speed": hourly.get("windspeed_10m"),
-        }
-    )
-    df = df.iloc[:limit].copy()
+def df_hourly(payload: dict, days: int) -> pd.DataFrame:
+    h = payload["hourly"]
+    df = pd.DataFrame({
+        "time": pd.to_datetime(h["time"]),
+        "temperature": h.get("temperature_2m"),
+        "apparent_temperature": h.get("apparent_temperature"),
+        "humidity_%": h.get("relativehumidity_2m"),
+        "precip": h.get("precipitation"),
+        "wind_speed_10m": h.get("windspeed_10m"),
+    })
+    # Limit to requested window exactly (API can return more than needed)
+    df = df.iloc[: int(days) * 24].copy()
     return df
 
 
-def plot_series(x, y, title, xlabel="Time", ylabel=""):
-    plt.figure(figsize=(9, 3.5))
-    plt.plot(x, y)
+def make_plot(x, y_list, labels, title, xlabel, ylabel) -> bytes:
+    plt.figure(figsize=(9, 3.8))
+    for y in y_list:
+        plt.plot(x, y)
+    if labels:
+        plt.legend(labels)
     plt.title(title)
     plt.xlabel(xlabel)
     plt.ylabel(ylabel)
@@ -107,131 +109,4 @@ def plot_series(x, y, title, xlabel="Time", ylabel=""):
     buf = io.BytesIO()
     plt.savefig(buf, format="png", dpi=150)
     plt.close()
-    buf.seek(0)
-    return buf
-
-
-def get_weather_forecast(
-    city,
-    forecast_type,
-    days,
-    temp_unit,
-    precip_unit,
-):
-    """
-    Main function that Gradio will call.
-    Returns: (markdown_summary, pandas.DataFrame, image_bytes)
-    """
-    try:
-        # 1) Geocode the city
-        loc = geocode_city(city)
-        lat = loc["latitude"]
-        lon = loc["longitude"]
-        display_name = f"{loc['name']}, {loc.get('country', '')} (lat {lat:.4f}, lon {lon:.4f})"
-
-        # 2) Fetch forecast
-        resp = fetch_forecast(lat, lon, days, forecast_type, temp_unit, precip_unit, loc["timezone"])
-
-        # 3) Build dataframe and plot
-        if forecast_type == "Daily":
-            if "daily" not in resp:
-                raise ValueError("Daily forecast data not available for this location.")
-            df = build_daily_df(resp["daily"])
-            # build a simple summary markdown
-            first = df.iloc[0]
-            summary = (
-                f"### Weather forecast for **{display_name}** — next {days} day(s)\n\n"
-                f"- **Today (first day)** — Max: {first['temp_max']} {temp_unit}, "
-                f"Min: {first['temp_min']} {temp_unit}, Precipitation: {first['precipitation']} {precip_unit}\n\n"
-                "Below is the daily table and a plot of daily high/low temperature."
-            )
-            # Plot highs and lows
-            img_buf = plot_series(
-                x=pd.to_datetime(df["date"]),
-                y=df["temp_max"],
-                title=f"Daily max temperature ({temp_unit}) — {loc['name']}",
-                xlabel="Date",
-                ylabel=f"Max temp ({temp_unit})",
-            )
-            # Add another line for min temp on same chart
-            # (create combined chart)
-            plt.figure(figsize=(9, 3.5))
-            plt.plot(pd.to_datetime(df["date"]), df["temp_max"])
-            plt.plot(pd.to_datetime(df["date"]), df["temp_min"])
-            plt.legend(["max", "min"])
-            plt.title(f"Daily temperatures ({temp_unit}) — {loc['name']}")
-            plt.xlabel("Date")
-            plt.ylabel(f"Temperature ({temp_unit})")
-            plt.tight_layout()
-            buf = io.BytesIO()
-            plt.savefig(buf, format="png", dpi=150)
-            plt.close()
-            buf.seek(0)
-            image_bytes = buf.read()
-
-            return summary, df, image_bytes
-
-        else:  # Hourly
-            if "hourly" not in resp:
-                raise ValueError("Hourly forecast data not available for this location.")
-            df = build_hourly_df(resp["hourly"], days)
-            # Simple summary
-            next_12h = df.iloc[:12]
-            soon = next_12h.iloc[0]
-            summary = (
-                f"### Hourly forecast for **{display_name}** — next {days} day(s) (showing full table)\n\n"
-                f"- **Next available hour**: {soon['time']} — Temp: {soon['temperature']} {temp_unit}, "
-                f"Humidity: {soon['humidity']}%.\n\n"
-                "Below is the hourly table and a temperature time series for the selected period."
-            )
-            # Plot temperature vs time (first N hours)
-            img_buf = plot_series(
-                x=df["time"].dt.strftime("%Y-%m-%d %H:%M"),
-                y=df["temperature"],
-                title=f"Hourly temperature ({temp_unit}) — {loc['name']}",
-                xlabel="Time",
-                ylabel=f"Temperature ({temp_unit})",
-            )
-            image_bytes = img_buf.getvalue()
-            return summary, df, image_bytes
-
-    except Exception as e:
-        # Return the error message in the markdown output; other outputs empty
-        return f"**Error:** {str(e)}", pd.DataFrame(), None
-
-
-demo_description = """
-Simple Weather Forecast app using **Open-Meteo** (no API key required).
-- Enter a city name (e.g. "Karachi", "New York", "Tokyo").
-- Choose Daily or Hourly forecast and number of days.
-- Open-Meteo provides the data; this app geocodes the city automatically.
-"""
-
-with gr.Blocks() as demo:
-    gr.Markdown("# Weather Forecast (Gradio + Open-Meteo)\n" + demo_description)
-
-    with gr.Row():
-        with gr.Column(scale=2):
-            city_in = gr.Textbox(label="City name", placeholder="e.g. Karachi or San Francisco", value="Karachi")
-            forecast_type = gr.Radio(["Daily", "Hourly"], value="Daily", label="Forecast type")
-            days = gr.Slider(minimum=1, maximum=14, step=1, value=3, label="Days of forecast (1–14)")
-            temp_unit = gr.Radio(["°C", "°F"], value="°C", label="Temperature unit")
-            precip_unit = gr.Radio(["mm", "in"], value="mm", label="Precipitation unit")
-            submit = gr.Button("Get forecast")
-
-        with gr.Column(scale=3):
-            md_out = gr.Markdown("")
-            df_out = gr.Dataframe(headers=[""], interactive=False)
-            img_out = gr.Image(label="Plot", type="bytes")
-
-    def run(city, forecast_type, days, temp_unit, precip_unit):
-        return get_weather_forecast(city, forecast_type, days, temp_unit, precip_unit)
-
-    submit.click(
-        run,
-        inputs=[city_in, forecast_type, days, temp_unit, precip_unit],
-        outputs=[md_out, df_out, img_out],
-    )
-
-if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    buf.seek(