fist push the app

README.md

@@ -1,15 +1,67 @@
 ---
-title: WeatherPred
-emoji: 💬
-colorFrom: yellow
-colorTo: purple
+title: Tokyo Weather Forecast Lab
 sdk: gradio
-sdk_version: 6.5.1
 app_file: app.py
 pinned: false
-hf_oauth: true
-hf_oauth_scopes:
-- inference-api
 ---
 
-An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).
+# WeatherPred
+
+A Gradio app for comparing Tokyo five-day weather forecasts from Open-Meteo with a local ONNX model forecast.
+
+## Repository Layout
+
+```text
+app.py                    # HuggingFace Spaces entrypoint
+weatherpred/              # Application package
+  config.py               # Paths, constants, Tokyo coordinates
+  data.py                 # Open-Meteo fetch and CSV/JSON cache
+  modeling.py             # ONNX inference and forecast comparison
+  agent.py                # Gemini-backed agent orchestration and fallback logic
+  prompts.py              # LLM routing and response prompts
+  tools.py                # Deterministic forecast/trend/seasonality/model tools
+  dashboard.py            # Gradio UI
+  zerogpu.py              # HuggingFace ZeroGPU compatibility
+models/mock_model/        # ONNX model artifacts
+scripts/                  # Data/model utility scripts
+requirements.txt          # Runtime dependencies
+requirements-train.txt    # Optional model training dependencies
+```
+
+## Local Run
+
+```bash
+pip install -r requirements.txt
+python scripts/fetch_historical_weather.py
+python app.py
+```
+
+## HuggingFace ZeroGPU
+
+Free HuggingFace Gradio Spaces may run on ZeroGPU only. A tiny hidden compatibility probe is decorated with `@spaces.GPU(duration=10)` so the Space satisfies the ZeroGPU startup check, while the real weather dashboard refresh remains CPU-based. The local fallback keeps the app runnable outside HuggingFace.
+
+## Agent Capabilities
+
+The chat agent uses Gemini when `GEMINI_API_KEY` is available, with a deterministic fallback parser when it is not. It can route user requests to typed Python tools for:
+
+- next-N-day forecasts, up to 16 days
+- historical trends over the cached weather history
+- seasonal/monthly cyclic patterns
+- model-vs-Open-Meteo comparison
+- model and data-source explanation
+
+The LLM does not invent forecasts directly; it selects tools and explains their computed results.
+
+## Optional Gemini Briefing
+
+Set `GEMINI_API_KEY` as a HuggingFace Space secret. If it is absent, the app uses deterministic fallback summaries and routing.
+
+## Optional Model Export
+
+```bash
+pip install -r requirements-train.txt
+python scripts/fetch_historical_weather.py
+python scripts/train_export_onnx.py
+```
+
+The training helper exports the ONNX model to `models/mock_model/model.onnx`.

app.py

@@ -1,69 +1,7 @@
-import gradio as gr
-from huggingface_hub import InferenceClient
+"""HuggingFace Spaces entrypoint for the Gradio app."""
 
-
-def respond(
-    message,
-    history: list[dict[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-    hf_token: gr.OAuthToken,
-):
-    """
-    For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-    """
-    client = InferenceClient(token=hf_token.token, model="openai/gpt-oss-20b")
-
-    messages = [{"role": "system", "content": system_message}]
-
-    messages.extend(history)
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        choices = message.choices
-        token = ""
-        if len(choices) and choices[0].delta.content:
-            token = choices[0].delta.content
-
-        response += token
-        yield response
-
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-chatbot = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
-
-with gr.Blocks() as demo:
-    with gr.Sidebar():
-        gr.LoginButton()
-    chatbot.render()
+from weatherpred.dashboard import demo
 
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(ssr_mode=False)

requirements-train.txt

@@ -0,0 +1,2 @@
+-r requirements.txt
+torch

requirements.txt

@@ -0,0 +1,7 @@
+gradio
+google-genai
+numpy
+onnxruntime
+pandas
+plotly
+requests

scripts/fetch_historical_weather.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+"""Fetch and cache 30 years of Tokyo daily weather data."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from weatherpred.config import HISTORY_CSV_PATH, HISTORY_JSON_PATH
+from weatherpred.data import fetch_historical_weather, save_history
+
+
+def main() -> None:
+    history = fetch_historical_weather()
+    save_history(history)
+    print(f"Wrote {len(history):,} rows to {HISTORY_CSV_PATH}")
+    print(f"Wrote JSON copy to {HISTORY_JSON_PATH}")
+
+
+if __name__ == "__main__":
+    main()

scripts/smoke_test_gradio_app.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+"""Offline smoke tests for the Gradio weather app core."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import pandas as pd
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from weatherpred.config import FORECAST_DAYS
+from weatherpred.modeling import seasonal_reference
+
+
+def main() -> None:
+    dates = pd.date_range("2020-01-01", periods=400, freq="D")
+    history = pd.DataFrame(
+        {
+            "date": dates,
+            "high_c": [20.0 + (index % 10) for index in range(len(dates))],
+            "low_c": [12.0 + (index % 7) for index in range(len(dates))],
+            "rain_mm": [float(index % 3) for index in range(len(dates))],
+            "wind_kmh": [10.0 + (index % 5) for index in range(len(dates))],
+            "confidence": 1.0,
+        }
+    )
+    forecast_dates = list(pd.date_range("2021-02-04", periods=FORECAST_DAYS, freq="D"))
+    reference = seasonal_reference(history, forecast_dates)
+
+    assert len(reference) == FORECAST_DAYS
+    assert {"seasonal_low_gap", "rain_mm", "wind_kmh", "high_std"}.issubset(reference.columns)
+    assert reference["rain_mm"].notna().all()
+    print("Gradio app core smoke test passed.")
+
+
+if __name__ == "__main__":
+    main()

scripts/train_export_onnx.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+"""Train a tiny demo weather model and export it to ONNX.
+
+This is intentionally simple: it learns from daily max temperature only and
+predicts the next five max-temperature values from the previous seven days.
+Use it as a scaffold for replacing the mock model with a stronger architecture.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn as nn
+import torch.optim as optim
+
+
+LOOKBACK_DAYS = 7
+FORECAST_DAYS = 5
+HISTORY_CSV_PATH = Path("data/tokyo_weather_history_30y.csv")
+ONNX_PATH = Path("models/mock_model/model.onnx")
+PT_PATH = Path("models/mock_model/model.pt")
+
+
+class MovingAverageForecastModel(nn.Module):
+    def __init__(self, lookback: int, forecast: int) -> None:
+        super().__init__()
+        self.fc = nn.Linear(lookback, forecast)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.fc(x)
+
+
+def create_sequences(values: np.ndarray) -> tuple[torch.Tensor, torch.Tensor]:
+    x_values = []
+    y_values = []
+    for index in range(len(values) - LOOKBACK_DAYS - FORECAST_DAYS + 1):
+        x_values.append(values[index : index + LOOKBACK_DAYS])
+        y_values.append(values[index + LOOKBACK_DAYS : index + LOOKBACK_DAYS + FORECAST_DAYS])
+    return (
+        torch.tensor(np.array(x_values), dtype=torch.float32),
+        torch.tensor(np.array(y_values), dtype=torch.float32),
+    )
+
+
+def load_training_values() -> np.ndarray:
+    if not HISTORY_CSV_PATH.exists():
+        raise FileNotFoundError(
+            f"{HISTORY_CSV_PATH} does not exist. Run scripts/fetch_historical_weather.py first."
+        )
+    history = pd.read_csv(HISTORY_CSV_PATH)
+    return history["high_c"].dropna().to_numpy(dtype=np.float32)
+
+
+def main() -> None:
+    values = load_training_values()
+    x_train, y_train = create_sequences(values)
+
+    model = MovingAverageForecastModel(LOOKBACK_DAYS, FORECAST_DAYS)
+    optimizer = optim.Adam(model.parameters(), lr=0.01)
+    criterion = nn.MSELoss()
+
+    with torch.no_grad():
+        model.fc.weight.fill_(1.0 / LOOKBACK_DAYS)
+        model.fc.bias.fill_(0.0)
+
+    model.train()
+    for epoch in range(120):
+        optimizer.zero_grad()
+        predictions = model(x_train)
+        loss = criterion(predictions, y_train)
+        loss.backward()
+        optimizer.step()
+
+    ONNX_PATH.parent.mkdir(parents=True, exist_ok=True)
+    torch.save(model.state_dict(), PT_PATH)
+    dummy_input = torch.zeros(1, LOOKBACK_DAYS, dtype=torch.float32)
+    torch.onnx.export(
+        model,
+        dummy_input,
+        ONNX_PATH,
+        input_names=["input"],
+        output_names=["forecast"],
+        dynamic_axes={"input": {0: "batch"}, "forecast": {0: "batch"}},
+        opset_version=17,
+    )
+    print(f"Saved PyTorch weights to {PT_PATH}")
+    print(f"Exported ONNX model to {ONNX_PATH}")
+
+
+if __name__ == "__main__":
+    main()

weatherpred/__init__.py

@@ -0,0 +1 @@
+"""Tokyo weather forecast demo package."""

weatherpred/agent.py

@@ -0,0 +1,203 @@
+"""LLM-backed agent and deterministic weather briefing helpers."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from dataclasses import dataclass
+from typing import Any
+
+import pandas as pd
+
+from weatherpred.prompts import AGENT_RESPONSE_PROMPT, AGENT_SYSTEM_PROMPT
+from weatherpred.tools import clamp_horizon, normalize_variable, run_tool
+
+
+@dataclass
+class AgentRun:
+    response: str
+    action: dict[str, Any]
+    tool_result: dict[str, Any]
+    comparison: pd.DataFrame | None = None
+
+
+def has_gemini_key() -> bool:
+    return bool(os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY"))
+
+
+def make_rule_based_brief(comparison: pd.DataFrame, summary: dict[str, Any]) -> str:
+    warmest = comparison.sort_values("model_high_c", ascending=False).iloc[0]
+    rainiest = comparison.sort_values("api_rain_mm", ascending=False).iloc[0]
+    confidence = round(summary["avg_model_confidence"] * 100)
+    return (
+        f"The ONNX model expects the warmest day around {warmest['date']} "
+        f"at {warmest['model_high_c']:.1f}C, while Open-Meteo peaks at "
+        f"{summary['max_api_high_c']:.1f}C. API rainfall is highest on "
+        f"{rainiest['date']} at {rainiest['api_rain_mm']:.1f} mm. "
+        f"The model confidence proxy averages {confidence}%, based on historical "
+        "seasonal variability rather than a calibrated meteorological probability."
+    )
+
+
+def make_gemini_brief(comparison: pd.DataFrame, summary: dict[str, Any]) -> str:
+    if not has_gemini_key():
+        return make_rule_based_brief(comparison, summary)
+
+    try:
+        from google import genai
+    except ImportError:
+        return make_rule_based_brief(comparison, summary)
+
+    prompt = (
+        "Write a concise weather analyst briefing for Tokyo. Compare an ONNX "
+        "model forecast against Open-Meteo API forecast. Mention uncertainty and "
+        "avoid claiming this model is production-grade.\n\n"
+        f"Summary: {json.dumps(summary)}\n"
+        f"Forecast rows: {comparison.to_json(orient='records')}"
+    )
+    try:
+        client = genai.Client()
+        response = client.models.generate_content(
+            model=os.getenv("GEMINI_MODEL", "gemini-2.5-flash"),
+            contents=prompt,
+        )
+        return response.text or make_rule_based_brief(comparison, summary)
+    except Exception:
+        return make_rule_based_brief(comparison, summary)
+
+
+def extract_json_object(text: str) -> dict[str, Any] | None:
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        pass
+    match = re.search(r"\{.*\}", text, flags=re.DOTALL)
+    if not match:
+        return None
+    try:
+        return json.loads(match.group(0))
+    except json.JSONDecodeError:
+        return None
+
+
+def fallback_action(user_message: str) -> dict[str, Any]:
+    text = user_message.lower()
+    horizon_match = re.search(r"(?:next|for)\s+(\d+)\s*(?:day|days)?", text)
+    horizon = clamp_horizon(horizon_match.group(1) if horizon_match else None)
+
+    if any(word in text for word in ["rain", "precip", "precipitation", "shower"]):
+        variable = "rain"
+    elif "wind" in text:
+        variable = "wind"
+    elif any(word in text for word in ["temperature", "temp", "hot", "cold", "high", "low"]):
+        variable = "temperature"
+    else:
+        variable = "all"
+
+    if any(word in text for word in ["season", "seasonal", "cycle", "cyclic", "monthly", "summer", "winter"]):
+        tool = "analyze_seasonality"
+    elif any(word in text for word in ["trend", "past", "historical", "history", "30 years", "long-term"]):
+        tool = "analyze_historical_trend"
+    elif any(word in text for word in ["model", "onnx", "confidence", "method", "how", "source", "data"]):
+        tool = "explain_model"
+    elif any(word in text for word in ["compare", "difference", "versus", "vs"]):
+        tool = "compare_model_vs_open_meteo"
+    elif horizon_match or any(word in text for word in ["predict", "forecast", "next"]):
+        tool = "forecast_next_days"
+    else:
+        tool = "show_dashboard_view"
+
+    return {"tool": tool, "variable": variable, "horizon_days": horizon, "reason": "fallback parser"}
+
+
+def infer_action(user_message: str) -> dict[str, Any]:
+    if not has_gemini_key():
+        return fallback_action(user_message)
+    try:
+        from google import genai
+
+        client = genai.Client()
+        prompt = f"{AGENT_SYSTEM_PROMPT}\n\nUser request: {user_message}"
+        response = client.models.generate_content(
+            model=os.getenv("GEMINI_MODEL", "gemini-2.5-flash"),
+            contents=prompt,
+        )
+        action = extract_json_object(response.text or "")
+        if action and "tool" in action:
+            action["variable"] = normalize_variable(action.get("variable"))
+            action["horizon_days"] = clamp_horizon(action.get("horizon_days"))
+            return action
+    except Exception:
+        pass
+    return fallback_action(user_message)
+
+
+def deterministic_agent_response(action: dict[str, Any], tool_result: dict[str, Any]) -> str:
+    tool = tool_result.get("tool", action.get("tool"))
+    summary = tool_result.get("summary", {})
+    variable = tool_result.get("variable", action.get("variable", "all"))
+
+    if tool == "forecast_next_days":
+        return (
+            f"Showing the next {tool_result['horizon_days']} days for {variable}. "
+            "Open-Meteo is shown beside the local model. Note: ONNX directly predicts five-day max temperature; "
+            "longer horizons, rain, wind, and low temperature use historical seasonal statistics."
+        )
+    if tool == "compare_model_vs_open_meteo":
+        return f"Model vs Open-Meteo comparison for {variable}: {json.dumps(summary.get('average_absolute_differences', {}))}."
+    if tool == "analyze_historical_trend":
+        return (
+            f"Historical {variable} trend from {summary['history_start']} to {summary['history_end']}: "
+            f"the recent five-year mean is {summary['last_5_year_mean']} {summary['unit']}, "
+            f"versus {summary['first_5_year_mean']} {summary['unit']} in the first five years. "
+            f"Change: {summary['change_last_vs_first']} {summary['unit']}."
+        )
+    if tool == "analyze_seasonality":
+        return (
+            f"Seasonality for {variable}: peak month is {summary['peak_month']} "
+            f"at {summary['peak_value']} {summary['unit']}; lowest month is {summary['low_month']} "
+            f"at {summary['low_value']} {summary['unit']}. Seasonal amplitude is "
+            f"{summary['seasonal_amplitude']} {summary['unit']}."
+        )
+    if tool == "explain_model":
+        return " ".join(str(value) for value in summary.values())
+    if tool == "show_dashboard_view":
+        return f"{variable.title()} is available in {summary['view']}."
+    return "I handled the request with the weather dashboard tools."
+
+
+def summarize_agent_response(user_message: str, action: dict[str, Any], tool_result: dict[str, Any]) -> str:
+    if not has_gemini_key():
+        return deterministic_agent_response(action, tool_result)
+    try:
+        from google import genai
+
+        safe_result = {key: value for key, value in tool_result.items() if key != "comparison"}
+        prompt = AGENT_RESPONSE_PROMPT.format(
+            user_message=user_message,
+            tool_result=json.dumps(safe_result, default=str),
+        )
+        client = genai.Client()
+        response = client.models.generate_content(
+            model=os.getenv("GEMINI_MODEL", "gemini-2.5-flash"),
+            contents=prompt,
+        )
+        return response.text or deterministic_agent_response(action, tool_result)
+    except Exception:
+        return deterministic_agent_response(action, tool_result)
+
+
+def run_weather_agent(user_message: str) -> AgentRun:
+    action = infer_action(user_message)
+    tool_result = run_tool(action)
+    response = summarize_agent_response(user_message, action, tool_result)
+    comparison = tool_result.get("comparison")
+    if not isinstance(comparison, pd.DataFrame):
+        comparison = None
+    return AgentRun(
+        response=response,
+        action=action,
+        tool_result=tool_result,
+        comparison=comparison,
+    )

weatherpred/config.py

@@ -0,0 +1,35 @@
+"""Project configuration constants."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+ROOT_DIR = Path(__file__).resolve().parents[1]
+DATA_DIR = ROOT_DIR / "data"
+MODELS_DIR = ROOT_DIR / "models"
+MODEL_PATH = MODELS_DIR / "mock_model" / "model.onnx"
+
+TOKYO_LATITUDE = 35.6762
+TOKYO_LONGITUDE = 139.6503
+TOKYO_TIMEZONE = "Asia/Tokyo"
+FORECAST_DAYS = 5
+LOOKBACK_DAYS = 7
+HISTORY_YEARS = 30
+
+HISTORY_CSV_PATH = DATA_DIR / "tokyo_weather_history_30y.csv"
+HISTORY_JSON_PATH = DATA_DIR / "tokyo_weather_history_30y.json"
+LATEST_JSON_PATH = DATA_DIR / "tokyo_weather_latest.json"
+
+DAILY_COLUMNS = [
+    "temperature_2m_max",
+    "temperature_2m_min",
+    "precipitation_sum",
+    "wind_speed_10m_max",
+]
+
+API_DISPLAY_COLUMNS = {
+    "high_c": "api_high_c",
+    "low_c": "api_low_c",
+    "rain_mm": "api_rain_mm",
+    "wind_kmh": "api_wind_kmh",
+}

weatherpred/dashboard.py

@@ -0,0 +1,246 @@
+"""Gradio dashboard assembly."""
+
+from __future__ import annotations
+
+import gradio as gr
+import pandas as pd
+import plotly.graph_objects as go
+
+from weatherpred.agent import make_gemini_brief, run_weather_agent
+from weatherpred.modeling import build_weather_bundle
+from weatherpred.zerogpu import spaces
+
+def make_line_plot(
+    comparison: pd.DataFrame,
+    title: str,
+    yaxis_title: str,
+    series: list[tuple[str, str, str]],
+) -> go.Figure:
+    fig = go.Figure()
+    for column, name, color in series:
+        fig.add_trace(
+            go.Scatter(
+                x=comparison["date"],
+                y=comparison[column],
+                mode="lines+markers",
+                name=name,
+                line={"color": color, "width": 3},
+            )
+        )
+    fig.update_layout(
+        title=title,
+        xaxis_title="Date",
+        yaxis_title=yaxis_title,
+        hovermode="x unified",
+        template="plotly_white",
+        legend={"orientation": "h", "y": -0.25},
+        margin={"l": 40, "r": 20, "t": 60, "b": 70},
+    )
+    return fig
+
+
+def make_temperature_plot(comparison: pd.DataFrame) -> go.Figure:
+    return make_line_plot(
+        comparison,
+        "Five-Day Temperature Forecast",
+        "Temperature (C)",
+        [
+            ("api_high_c", "Open-Meteo high", "#0f8b8d"),
+            ("model_high_c", "ONNX model high", "#e05d3d"),
+            ("api_low_c", "Open-Meteo low", "#74b6b7"),
+            ("model_low_c", "ONNX model low", "#f0a08c"),
+        ],
+    )
+
+
+def make_rain_plot(comparison: pd.DataFrame) -> go.Figure:
+    return make_line_plot(
+        comparison,
+        "Five-Day Rain Forecast",
+        "Rain (mm)",
+        [
+            ("api_rain_mm", "Open-Meteo rain", "#0f8b8d"),
+            ("model_rain_mm", "Model rain proxy", "#e05d3d"),
+        ],
+    )
+
+
+def make_wind_plot(comparison: pd.DataFrame) -> go.Figure:
+    return make_line_plot(
+        comparison,
+        "Five-Day Wind Forecast",
+        "Wind (km/h)",
+        [
+            ("api_wind_kmh", "Open-Meteo wind", "#0f8b8d"),
+            ("model_wind_kmh", "Historical model wind", "#e05d3d"),
+        ],
+    )
+
+
+@spaces.GPU(duration=10)
+def zero_gpu_probe() -> str:
+    return "ZeroGPU compatibility probe is available."
+
+
+def make_metrics(summary: dict) -> str:
+    return (
+        f"Historical rows: {summary['history_rows']:,}\n"
+        f"History window: {summary['history_start']} to {summary['history_end']}\n"
+        f"Average model confidence proxy: {summary['avg_model_confidence']:.0%}\n"
+        f"Open-Meteo max high: {summary['max_api_high_c']:.1f}C\n"
+        f"ONNX model max high: {summary['max_model_high_c']:.1f}C"
+    )
+
+
+def render_all_charts(comparison: pd.DataFrame) -> tuple:
+    return (
+        gr.update(value=make_temperature_plot(comparison), visible=True),
+        gr.update(value=make_rain_plot(comparison), visible=True),
+        gr.update(value=make_wind_plot(comparison), visible=True),
+    )
+
+
+def refresh_dashboard(force_refresh_history: bool) -> tuple:
+    bundle = build_weather_bundle(force_refresh_history=force_refresh_history)
+    comparison = bundle.comparison.copy()
+    summary = bundle.summary
+    brief = make_gemini_brief(comparison, summary)
+    return (
+        comparison,
+        "all",
+        make_temperature_plot(comparison),
+        make_rain_plot(comparison),
+        make_wind_plot(comparison),
+        make_metrics(summary),
+        brief,
+        [{"role": "assistant", "content": "Dashboard refreshed. Showing temperature, rain, and wind forecasts."}],
+    )
+
+
+def parse_chart_selection(message: str) -> tuple[str, str]:
+    text = message.lower()
+    wants_temperature = any(word in text for word in ["temperature", "temp", "hot", "cold", "high", "low"])
+    wants_rain = any(word in text for word in ["rain", "precipitation", "precip", "shower"])
+    wants_wind = "wind" in text
+    wants_all = any(word in text for word in ["all", "everything", "reset", "both"])
+
+    if wants_all or sum([wants_temperature, wants_rain, wants_wind]) > 1:
+        return "all", "Showing all three charts in the fixed 2x2 layout."
+    if wants_temperature:
+        return "temperature", "Temperature is shown in the top-left chart."
+    if wants_rain:
+        return "rain", "Rain is shown in the top-right chart."
+    if wants_wind:
+        return "wind", "Wind is shown in the bottom-left chart, including the historical model wind prediction."
+    return "all", "I can point you to temperature, rain, wind, or all charts in the 2x2 dashboard."
+
+
+def chat_with_dashboard(message: str, history: list, comparison: pd.DataFrame) -> tuple:
+    if comparison is None or getattr(comparison, "empty", True):
+        comparison = build_weather_bundle(force_refresh_history=False).comparison.copy()
+
+    if not message.strip():
+        return (history or [], "all", comparison, *render_all_charts(comparison), "")
+
+    agent_run = run_weather_agent(message)
+    next_comparison = agent_run.comparison if agent_run.comparison is not None else comparison
+    charts = render_all_charts(next_comparison)
+    history = history or []
+    history.append({"role": "user", "content": message})
+    history.append({"role": "assistant", "content": agent_run.response})
+    selection = agent_run.action.get("variable", "all")
+    return (history, selection, next_comparison, *charts, agent_run.response)
+
+
+with gr.Blocks(title="Tokyo Weather Forecast Lab") as demo:
+    gr.Markdown(
+        """
+        # Tokyo Weather Forecast Lab
+
+        Compare Open-Meteo's five-day forecast with a local ONNX model using
+        cached 30-year Tokyo weather history. Use the chat panel to show
+        temperature, rain, wind, or all forecast charts in the fixed 2x2 layout.
+        """
+    )
+    forecast_state = gr.State(pd.DataFrame())
+    chart_selection = gr.State("all")
+
+    with gr.Row():
+        refresh = gr.Button("Refresh forecast", variant="primary")
+        force_history = gr.Checkbox(
+            label="Refresh 30-year historical cache",
+            value=False,
+        )
+
+    with gr.Row(visible=False):
+        gpu_probe_button = gr.Button("ZeroGPU probe")
+        gpu_probe_output = gr.Textbox(label="ZeroGPU probe")
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            temperature_plot = gr.Plot(label="Temperature")
+        with gr.Column(scale=1):
+            rain_plot = gr.Plot(label="Rain")
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            wind_plot = gr.Plot(label="Wind")
+        with gr.Column(scale=1):
+            gr.Markdown("## Forecast Chat")
+            chatbot = gr.Chatbot(label="Dashboard assistant", height=360)
+            chat_input = gr.Textbox(
+                label="Ask the dashboard",
+                placeholder="Try: show rain, show wind, show temperature, show all charts",
+            )
+
+    with gr.Row():
+        metrics_box = gr.Textbox(label="Data and model metrics", lines=6)
+        brief_box = gr.Textbox(label="AI analyst brief", lines=6)
+
+    gpu_probe_button.click(
+        zero_gpu_probe,
+        inputs=None,
+        outputs=gpu_probe_output,
+    )
+
+    refresh.click(
+        refresh_dashboard,
+        inputs=[force_history],
+        outputs=[
+            forecast_state,
+            chart_selection,
+            temperature_plot,
+            rain_plot,
+            wind_plot,
+            metrics_box,
+            brief_box,
+            chatbot,
+        ],
+    )
+    demo.load(
+        refresh_dashboard,
+        inputs=[force_history],
+        outputs=[
+            forecast_state,
+            chart_selection,
+            temperature_plot,
+            rain_plot,
+            wind_plot,
+            metrics_box,
+            brief_box,
+            chatbot,
+        ],
+    )
+    chat_input.submit(
+        chat_with_dashboard,
+        inputs=[chat_input, chatbot, forecast_state],
+        outputs=[
+            chatbot,
+            chart_selection,
+            forecast_state,
+            temperature_plot,
+            rain_plot,
+            wind_plot,
+            brief_box,
+        ],
+    ).then(lambda: "", outputs=chat_input)

weatherpred/data.py

@@ -0,0 +1,108 @@
+"""Open-Meteo data fetching and local CSV/JSON cache helpers."""
+
+from __future__ import annotations
+
+import json
+from datetime import date, datetime, timedelta, timezone
+from typing import Any
+
+import numpy as np
+import pandas as pd
+import requests
+
+from weatherpred.config import (
+    DAILY_COLUMNS,
+    DATA_DIR,
+    FORECAST_DAYS,
+    HISTORY_CSV_PATH,
+    HISTORY_JSON_PATH,
+    HISTORY_YEARS,
+    LATEST_JSON_PATH,
+    TOKYO_LATITUDE,
+    TOKYO_LONGITUDE,
+    TOKYO_TIMEZONE,
+)
+
+
+def fetch_json(url: str, params: dict[str, str | float | int]) -> dict[str, Any]:
+    response = requests.get(url, params=params, timeout=40)
+    response.raise_for_status()
+    return response.json()
+
+
+def normalize_daily_weather(raw: dict[str, Any], observed: bool) -> pd.DataFrame:
+    daily = raw["daily"]
+    frame = pd.DataFrame(
+        {
+            "date": pd.to_datetime(daily["time"]),
+            "high_c": daily["temperature_2m_max"],
+            "low_c": daily["temperature_2m_min"],
+            "rain_mm": daily["precipitation_sum"],
+            "wind_kmh": daily["wind_speed_10m_max"],
+        }
+    )
+    frame["confidence"] = 1.0 if observed else np.nan
+    return frame.dropna(subset=["high_c", "low_c", "rain_mm", "wind_kmh"])
+
+
+def fetch_historical_weather(
+    years: int = HISTORY_YEARS,
+    latitude: float = TOKYO_LATITUDE,
+    longitude: float = TOKYO_LONGITUDE,
+) -> pd.DataFrame:
+    end = date.today() - timedelta(days=1)
+    start = end.replace(year=end.year - years)
+    params = {
+        "latitude": latitude,
+        "longitude": longitude,
+        "timezone": TOKYO_TIMEZONE,
+        "start_date": start.isoformat(),
+        "end_date": end.isoformat(),
+        "daily": ",".join(DAILY_COLUMNS),
+    }
+    raw = fetch_json("https://archive-api.open-meteo.com/v1/archive", params)
+    return normalize_daily_weather(raw, observed=True)
+
+
+def fetch_api_forecast(
+    latitude: float = TOKYO_LATITUDE,
+    longitude: float = TOKYO_LONGITUDE,
+    days: int = FORECAST_DAYS,
+) -> pd.DataFrame:
+    params = {
+        "latitude": latitude,
+        "longitude": longitude,
+        "timezone": TOKYO_TIMEZONE,
+        "forecast_days": days,
+        "current": "temperature_2m,precipitation,wind_speed_10m",
+        "daily": ",".join(DAILY_COLUMNS),
+    }
+    raw = fetch_json("https://api.open-meteo.com/v1/forecast", params)
+    latest = {
+        "fetched_at": datetime.now(timezone.utc).isoformat(),
+        "current": raw.get("current", {}),
+        "daily": raw.get("daily", {}),
+    }
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    LATEST_JSON_PATH.write_text(json.dumps(latest, indent=2) + "\n", encoding="utf-8")
+    return normalize_daily_weather(raw, observed=False)
+
+
+def save_history(history: pd.DataFrame) -> None:
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    history.to_csv(HISTORY_CSV_PATH, index=False)
+    HISTORY_JSON_PATH.write_text(
+        history.assign(date=history["date"].dt.strftime("%Y-%m-%d")).to_json(
+            orient="records", indent=2
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+
+
+def load_or_fetch_history(force_refresh: bool = False) -> pd.DataFrame:
+    if HISTORY_CSV_PATH.exists() and not force_refresh:
+        return pd.read_csv(HISTORY_CSV_PATH, parse_dates=["date"])
+    history = fetch_historical_weather()
+    save_history(history)
+    return history

weatherpred/modeling.py

@@ -0,0 +1,128 @@
+"""ONNX weather inference and forecast comparison logic."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any
+
+import numpy as np
+import pandas as pd
+
+from weatherpred.config import (
+    API_DISPLAY_COLUMNS,
+    FORECAST_DAYS,
+    LOOKBACK_DAYS,
+    MODEL_PATH,
+)
+
+
+@dataclass
+class WeatherBundle:
+    history: pd.DataFrame
+    api_forecast: pd.DataFrame
+    model_forecast: pd.DataFrame
+    comparison: pd.DataFrame
+    summary: dict[str, Any]
+
+
+def run_onnx_temperature_model(history: pd.DataFrame) -> np.ndarray:
+    recent_highs = (
+        history.sort_values("date")["high_c"].tail(LOOKBACK_DAYS).to_numpy(dtype=np.float32)
+    )
+    if len(recent_highs) < LOOKBACK_DAYS:
+        raise ValueError(f"Need at least {LOOKBACK_DAYS} historical days for ONNX inference.")
+
+    try:
+        import onnxruntime as ort
+    except ImportError as exc:
+        raise RuntimeError(
+            "onnxruntime is required to run models/mock_model/model.onnx. "
+            "Install requirements.txt or deploy on HuggingFace Spaces."
+        ) from exc
+
+    session = ort.InferenceSession(str(MODEL_PATH), providers=["CPUExecutionProvider"])
+    input_name = session.get_inputs()[0].name
+    output_name = session.get_outputs()[0].name
+    prediction = session.run([output_name], {input_name: recent_highs.reshape(1, -1)})[0]
+    return np.asarray(prediction, dtype=float).reshape(-1)[:FORECAST_DAYS]
+
+
+def seasonal_reference(history: pd.DataFrame, forecast_dates: list[pd.Timestamp]) -> pd.DataFrame:
+    frame = history.copy()
+    frame["day_of_year"] = frame["date"].dt.dayofyear
+    rows = []
+    for forecast_date in forecast_dates:
+        day_of_year = forecast_date.dayofyear
+        window = frame[
+            (frame["day_of_year"] >= day_of_year - 14)
+            & (frame["day_of_year"] <= day_of_year + 14)
+        ]
+        if window.empty:
+            window = frame.tail(365)
+        rows.append(
+            {
+                "date": forecast_date,
+                "seasonal_high_c": float(window["high_c"].median()),
+                "seasonal_low_gap": float((window["high_c"] - window["low_c"]).median()),
+                "rain_mm": float(window["rain_mm"].median()),
+                "wind_kmh": float(window["wind_kmh"].median()),
+                "high_std": float(window["high_c"].std(ddof=0) or 3.0),
+            }
+        )
+    return pd.DataFrame(rows)
+
+
+def build_model_forecast(history: pd.DataFrame, api_forecast: pd.DataFrame) -> pd.DataFrame:
+    forecast_dates = list(api_forecast["date"])
+    seasonal = seasonal_reference(history, forecast_dates)
+    predicted_highs = run_onnx_temperature_model(history)
+    horizon = len(forecast_dates)
+    if horizon <= len(predicted_highs):
+        model_highs = predicted_highs[:horizon]
+    else:
+        seasonal_extension = seasonal["seasonal_high_c"].to_numpy(dtype=float)[len(predicted_highs) : horizon]
+        model_highs = np.concatenate([predicted_highs, seasonal_extension])
+
+    result = pd.DataFrame({"date": forecast_dates, "model_high_c": model_highs})
+    result = result.merge(seasonal, on="date", how="left")
+    result["model_low_c"] = result["model_high_c"] - result["seasonal_low_gap"]
+    result["model_rain_mm"] = result["rain_mm"].clip(lower=0)
+    result["model_wind_kmh"] = result["wind_kmh"].clip(lower=0)
+    result["model_confidence"] = (1 - (result["high_std"] / 12)).clip(lower=0.45, upper=0.88)
+    return result[
+        [
+            "date",
+            "model_high_c",
+            "model_low_c",
+            "model_rain_mm",
+            "model_wind_kmh",
+            "model_confidence",
+        ]
+    ]
+
+
+def build_weather_bundle(force_refresh_history: bool = False, horizon_days: int = FORECAST_DAYS) -> WeatherBundle:
+    from weatherpred.data import fetch_api_forecast, load_or_fetch_history
+
+    history = load_or_fetch_history(force_refresh=force_refresh_history)
+    api_forecast = fetch_api_forecast(days=horizon_days)
+    model_forecast = build_model_forecast(history, api_forecast)
+
+    comparison = api_forecast.rename(columns=API_DISPLAY_COLUMNS).merge(
+        model_forecast, on="date", how="inner"
+    )
+    comparison["date"] = comparison["date"].dt.strftime("%Y-%m-%d")
+    comparison["high_delta_c"] = comparison["model_high_c"] - comparison["api_high_c"]
+    comparison["rain_delta_mm"] = comparison["model_rain_mm"] - comparison["api_rain_mm"]
+
+    summary = {
+        "history_rows": int(len(history)),
+        "history_start": history["date"].min().strftime("%Y-%m-%d"),
+        "history_end": history["date"].max().strftime("%Y-%m-%d"),
+        "fetched_at": datetime.now(timezone.utc).isoformat(),
+        "avg_model_confidence": float(model_forecast["model_confidence"].mean()),
+        "max_api_high_c": float(api_forecast["high_c"].max()),
+        "max_model_high_c": float(model_forecast["model_high_c"].max()),
+    }
+    return WeatherBundle(history, api_forecast, model_forecast, comparison, summary)

weatherpred/prompts.py

@@ -0,0 +1,54 @@
+"""Prompts for the weather dashboard agent."""
+
+AGENT_SYSTEM_PROMPT = """
+You are the routing layer for a Tokyo weather forecasting dashboard.
+Your job is to convert the user request into exactly one JSON action.
+Return JSON only. Do not include markdown.
+
+Allowed variables:
+- temperature
+- rain
+- wind
+- all
+
+Allowed tools:
+- forecast_next_days: predict/show the next N days. Args: variable, horizon_days.
+- analyze_historical_trend: summarize long-term trend over historical data. Args: variable.
+- analyze_seasonality: summarize seasonal or cyclic behavior. Args: variable.
+- compare_model_vs_open_meteo: compare model output and Open-Meteo forecast. Args: variable, horizon_days.
+- explain_model: explain data sources, model limits, and forecasting method. Args: none.
+- show_dashboard_view: direct user to an existing dashboard view. Args: variable.
+
+Rules:
+- If the user asks for next N days, choose forecast_next_days and extract N.
+- If N is absent for a forecast or comparison, use 5.
+- Clamp horizon_days to 1-16.
+- If the user asks about the past, historical trend, long-term movement, 30 years, or change over time, choose analyze_historical_trend.
+- If the user asks about seasonal, yearly, monthly, cyclic, summer, winter, or periodic behavior, choose analyze_seasonality.
+- If the user asks how the model works, what model is used, confidence, limitations, ONNX, or data source, choose explain_model.
+- If the user asks to show a fixed chart without analytical wording, choose show_dashboard_view.
+
+JSON schema:
+{
+  "tool": "forecast_next_days | analyze_historical_trend | analyze_seasonality | compare_model_vs_open_meteo | explain_model | show_dashboard_view",
+  "variable": "temperature | rain | wind | all",
+  "horizon_days": 5,
+  "reason": "brief internal reason"
+}
+""".strip()
+
+AGENT_RESPONSE_PROMPT = """
+You are a concise weather analyst for a Tokyo forecasting dashboard.
+Use the tool result below to answer the user.
+Be clear about model limits:
+- ONNX model directly predicts only max temperature for the first five days.
+- Min temperature, rain, wind, and horizons beyond five days use historical seasonal statistics.
+- Open-Meteo is the external weather API baseline.
+Avoid investment-like certainty and avoid pretending the model is production-grade.
+
+User request:
+{user_message}
+
+Tool result JSON:
+{tool_result}
+""".strip()

weatherpred/tools.py

@@ -0,0 +1,200 @@
+"""Deterministic tools called by the weather dashboard agent."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+import pandas as pd
+
+from weatherpred.config import FORECAST_DAYS
+from weatherpred.modeling import build_weather_bundle
+
+MAX_FORECAST_DAYS = 16
+VARIABLE_COLUMNS = {
+    "temperature": {
+        "api": ["api_high_c", "api_low_c"],
+        "model": ["model_high_c", "model_low_c"],
+        "history": "high_c",
+        "unit": "C",
+    },
+    "rain": {
+        "api": ["api_rain_mm"],
+        "model": ["model_rain_mm"],
+        "history": "rain_mm",
+        "unit": "mm",
+    },
+    "wind": {
+        "api": ["api_wind_kmh"],
+        "model": ["model_wind_kmh"],
+        "history": "wind_kmh",
+        "unit": "km/h",
+    },
+}
+
+
+def normalize_variable(variable: str | None) -> str:
+    text = (variable or "all").lower()
+    if text in {"temp", "temperature", "hot", "cold"}:
+        return "temperature"
+    if text in {"rain", "precip", "precipitation", "shower"}:
+        return "rain"
+    if text in {"wind", "windspeed", "wind_speed"}:
+        return "wind"
+    return "all"
+
+
+def clamp_horizon(horizon_days: int | str | None) -> int:
+    try:
+        value = int(horizon_days or FORECAST_DAYS)
+    except (TypeError, ValueError):
+        value = FORECAST_DAYS
+    return max(1, min(MAX_FORECAST_DAYS, value))
+
+
+def compact_forecast_rows(comparison: pd.DataFrame, variable: str) -> list[dict[str, Any]]:
+    variable = normalize_variable(variable)
+    columns = ["date"]
+    selected = ["temperature", "rain", "wind"] if variable == "all" else [variable]
+    for item in selected:
+        columns.extend(VARIABLE_COLUMNS[item]["api"])
+        columns.extend(VARIABLE_COLUMNS[item]["model"])
+    return comparison[columns].round(2).to_dict(orient="records")
+
+
+def forecast_next_days(variable: str = "all", horizon_days: int = FORECAST_DAYS) -> dict[str, Any]:
+    variable = normalize_variable(variable)
+    horizon = clamp_horizon(horizon_days)
+    bundle = build_weather_bundle(horizon_days=horizon)
+    return {
+        "tool": "forecast_next_days",
+        "variable": variable,
+        "horizon_days": horizon,
+        "comparison": bundle.comparison,
+        "summary": {
+            **bundle.summary,
+            "rows": compact_forecast_rows(bundle.comparison, variable),
+            "model_note": "ONNX predicts max temperature for the first five days; other outputs use historical seasonal statistics.",
+        },
+    }
+
+
+def analyze_historical_trend(variable: str = "temperature") -> dict[str, Any]:
+    from weatherpred.data import load_or_fetch_history
+
+    variable = normalize_variable(variable)
+    if variable == "all":
+        variable = "temperature"
+    info = VARIABLE_COLUMNS[variable]
+    history = load_or_fetch_history(force_refresh=False).sort_values("date")
+    yearly = history.set_index("date")[info["history"]].resample("YE").mean().dropna()
+    x = np.arange(len(yearly), dtype=float)
+    slope = float(np.polyfit(x, yearly.to_numpy(dtype=float), 1)[0]) if len(yearly) > 1 else 0.0
+    first_mean = float(yearly.head(5).mean())
+    last_mean = float(yearly.tail(5).mean())
+    return {
+        "tool": "analyze_historical_trend",
+        "variable": variable,
+        "summary": {
+            "history_start": history["date"].min().strftime("%Y-%m-%d"),
+            "history_end": history["date"].max().strftime("%Y-%m-%d"),
+            "unit": info["unit"],
+            "first_5_year_mean": round(first_mean, 2),
+            "last_5_year_mean": round(last_mean, 2),
+            "change_last_vs_first": round(last_mean - first_mean, 2),
+            "linear_slope_per_year": round(slope, 3),
+        },
+    }
+
+
+def analyze_seasonality(variable: str = "temperature") -> dict[str, Any]:
+    from weatherpred.data import load_or_fetch_history
+
+    variable = normalize_variable(variable)
+    if variable == "all":
+        variable = "temperature"
+    info = VARIABLE_COLUMNS[variable]
+    history = load_or_fetch_history(force_refresh=False).copy()
+    history["month"] = history["date"].dt.month
+    monthly = history.groupby("month")[info["history"]].mean()
+    peak_month = int(monthly.idxmax())
+    low_month = int(monthly.idxmin())
+    return {
+        "tool": "analyze_seasonality",
+        "variable": variable,
+        "summary": {
+            "unit": info["unit"],
+            "peak_month": peak_month,
+            "peak_value": round(float(monthly.loc[peak_month]), 2),
+            "low_month": low_month,
+            "low_value": round(float(monthly.loc[low_month]), 2),
+            "seasonal_amplitude": round(float(monthly.max() - monthly.min()), 2),
+            "monthly_means": {str(month): round(float(value), 2) for month, value in monthly.items()},
+        },
+    }
+
+
+def compare_model_vs_open_meteo(variable: str = "all", horizon_days: int = FORECAST_DAYS) -> dict[str, Any]:
+    forecast = forecast_next_days(variable=variable, horizon_days=horizon_days)
+    comparison = forecast["comparison"]
+    variable = normalize_variable(variable)
+    selected = ["temperature", "rain", "wind"] if variable == "all" else [variable]
+    deltas: dict[str, Any] = {}
+    for item in selected:
+        if item == "temperature":
+            deltas["temperature_high_mae_c"] = round(float((comparison["model_high_c"] - comparison["api_high_c"]).abs().mean()), 2)
+            deltas["temperature_low_mae_c"] = round(float((comparison["model_low_c"] - comparison["api_low_c"]).abs().mean()), 2)
+        elif item == "rain":
+            deltas["rain_mae_mm"] = round(float((comparison["model_rain_mm"] - comparison["api_rain_mm"]).abs().mean()), 2)
+        elif item == "wind":
+            deltas["wind_mae_kmh"] = round(float((comparison["model_wind_kmh"] - comparison["api_wind_kmh"]).abs().mean()), 2)
+    forecast["tool"] = "compare_model_vs_open_meteo"
+    forecast["summary"]["average_absolute_differences"] = deltas
+    return forecast
+
+
+def explain_model() -> dict[str, Any]:
+    return {
+        "tool": "explain_model",
+        "variable": "all",
+        "summary": {
+            "data_source": "Open-Meteo archive API for history and Open-Meteo forecast API as an external baseline.",
+            "history_window": "Up to 30 years of daily Tokyo max/min temperature, precipitation, and max wind speed stored in local CSV/JSON cache.",
+            "model": "A small ONNX demo model loaded from models/mock_model/model.onnx.",
+            "direct_prediction": "The ONNX model directly predicts five days of max temperature from the previous seven daily max temperatures.",
+            "derived_outputs": "Min temperature, rain, wind, confidence, and horizons beyond five days are derived from historical seasonal statistics.",
+            "limitation": "This is an interview/demo forecasting scaffold, not a production meteorological model.",
+        },
+    }
+
+
+def show_dashboard_view(variable: str = "all") -> dict[str, Any]:
+    variable = normalize_variable(variable)
+    locations = {
+        "temperature": "top-left chart",
+        "rain": "top-right chart",
+        "wind": "bottom-left chart",
+        "all": "the three chart cells in the 2x2 layout",
+    }
+    return {
+        "tool": "show_dashboard_view",
+        "variable": variable,
+        "summary": {"view": locations[variable]},
+    }
+
+
+def run_tool(action: dict[str, Any]) -> dict[str, Any]:
+    tool = action.get("tool", "show_dashboard_view")
+    variable = normalize_variable(action.get("variable"))
+    horizon = clamp_horizon(action.get("horizon_days"))
+    if tool == "forecast_next_days":
+        return forecast_next_days(variable, horizon)
+    if tool == "analyze_historical_trend":
+        return analyze_historical_trend(variable)
+    if tool == "analyze_seasonality":
+        return analyze_seasonality(variable)
+    if tool == "compare_model_vs_open_meteo":
+        return compare_model_vs_open_meteo(variable, horizon)
+    if tool == "explain_model":
+        return explain_model()
+    return show_dashboard_view(variable)

weatherpred/zerogpu.py

@@ -0,0 +1,15 @@
+"""Compatibility wrapper for HuggingFace ZeroGPU's spaces package."""
+
+from __future__ import annotations
+
+try:
+    import spaces
+except ImportError:
+    class _SpacesFallback:
+        @staticmethod
+        def GPU(*_args, **_kwargs):
+            def decorator(function):
+                return function
+            return decorator
+
+    spaces = _SpacesFallback()