AI Assistant: Plain-Language Weather Guidance from METAR Data

import duckdb
import pandas as pd
from datetime import datetime, timedelta

# --- Pick a time (global snapshot: ALL stations at this hour) ---
year, month, day, hour = 2026, 1, 1, 0   # a past hour known to have data

time_1 = datetime(year, month, day, hour)
time_0 = time_1 - timedelta(hours=1)

# Build the data URLs (handles the year-boundary edge case)
YYYY_0, YYYY_1 = time_0.strftime("%Y"), time_1.strftime("%Y")
base = "https://data.source.coop/dynamical/asos-parquet"
if YYYY_0 == YYYY_1:
    URLs = [f"{base}/year={YYYY_1}/data.parquet"]
else:
    URLs = [f"{base}/year={YYYY_0}/data.parquet",
            f"{base}/year={YYYY_1}/data.parquet"]

# Query ALL stations worldwide for that hour
df = duckdb.execute("""
    SELECT valid, station, name, country, tmpf, dwpf, sknt, p01i, longitude, latitude
    FROM read_parquet($1, hive_partitioning=true)
    WHERE valid BETWEEN $2 AND $3
    ORDER BY country
""", [URLs, time_0, time_1]).fetchdf()

print(f"Retrieved {len(df)} station records for {time_1} UTC")
print(f"Countries represented: {df['country'].nunique()}")
df.head()

def extract_observation(df, station_code="DEN"):
    """From the global query result, pull one representative station's observation.
    Returns a dict; missing values become None so we can handle them honestly."""
    if df is None or len(df) == 0:
        return None  # no data at all

    # Filter the global dataframe down to our chosen station
    station_rows = df[df["station"] == station_code]
    if len(station_rows) == 0:
        return None  # this station not present in the data

    row = station_rows.iloc[-1]  # most recent observation for that station

    def safe(val):
        return None if pd.isna(val) else val

    return {
        "station": safe(row.get("station")),
        "name": safe(row.get("name")),
        "country": safe(row.get("country")),
        "time": str(safe(row.get("valid"))),
        "temp_f": safe(row.get("tmpf")),
        "dewpoint_f": safe(row.get("dwpf")),
        "wind_kt": safe(row.get("sknt")),
        "precip_in": safe(row.get("p01i")),
    }

# Denver as our representative station for plain-language guidance
obs = extract_observation(df, station_code="DEN")
obs

def generate_guidance_rule_based(obs):
    """Plain-language weather guidance for non-expert (e.g. agricultural) users.
    Honestly flags missing data instead of guessing."""
    if obs is None:
        return ("No weather observations were found for this station and time. "
                "I can't provide guidance without data — please try a nearby "
                "station or a different time.")

    where = obs["name"] or obs["station"] or "this location"
    lines = [f"Weather guidance for {where} (observed {obs['time']}):", ""]

    # Temperature
    if obs["temp_f"] is not None:
        t = obs["temp_f"]
        note = ""
        if t <= 32:
            note = " Freezing conditions — protect sensitive crops and livestock water."
        elif t >= 90:
            note = " Hot — ensure livestock have shade and water; avoid midday field labor."
        else:
            note = " Mild conditions, generally favorable for outdoor field work."
        lines.append(f"• Temperature: {t:.0f}°F.{note}")

    # Wind
    if obs["wind_kt"] is not None:
        mph = obs["wind_kt"] * 1.15
        note = " Too windy for safe spraying." if mph >= 10 else " Calm enough for spraying."
        lines.append(f"• Wind: about {mph:.0f} mph.{note}")
    else:
        lines.append("• Wind: not reported — do not assume calm conditions before spraying.")

    # Precipitation
    if obs["precip_in"] is not None:
        p = obs["precip_in"]
        note = " Recent rainfall — fields may be wet." if p > 0 else " No recent precipitation recorded."
        lines.append(f"• Precipitation (last hour): {p:.2f} in.{note}")
    else:
        lines.append("• Precipitation: not reported for this hour.")

    lines.append("")
    lines.append("Note: This guidance is based only on the available observations above. "
                 "Where a value is missing, no assumption has been made.")
    return "\n".join(lines)

print(generate_guidance_rule_based(obs))

import matplotlib.pyplot as plt

# Build a simple bar chart of the current observation's key fields
fields = []
values = []
if obs is not None:
    if obs["temp_f"] is not None:
        fields.append("Temperature (°F)"); values.append(obs["temp_f"])
    if obs["dewpoint_f"] is not None:
        fields.append("Dew point (°F)"); values.append(obs["dewpoint_f"])
    if obs["wind_kt"] is not None:
        fields.append("Wind (kt)"); values.append(obs["wind_kt"])
    if obs["precip_in"] is not None:
        fields.append("Precip (in)"); values.append(obs["precip_in"])

fig, ax = plt.subplots(figsize=(7, 4))
bars = ax.barh(fields, values, color="#3a7ca5")
ax.bar_label(bars, fmt="%.1f", padding=4)
ax.set_title(f"Observed conditions at {obs['name'] or obs['station']}", fontsize=13)
ax.set_xlabel("Value")
plt.tight_layout()
plt.show()

import matplotlib.pyplot as plt

# How many stations report from each country in this global snapshot?
country_counts = df["country"].value_counts()

fig, ax = plt.subplots(figsize=(8, 4.5))
bars = ax.bar(country_counts.index, country_counts.values, color="#3a7ca5")
ax.bar_label(bars, fmt="%d", padding=3, fontsize=8)
ax.set_title(f"Station coverage by country — only {df['country'].nunique()} countries "
             f"in this global snapshot", fontsize=12)
ax.set_xlabel("Country")
ax.set_ylabel("Number of stations reporting")
plt.xticks(rotation=45, ha="right")
plt.tight_layout()
plt.show()

print(f"This hour's data covers {df['country'].nunique()} countries: "
      f"{', '.join(sorted(df['country'].unique()))}")

import matplotlib.pyplot as plt

# Plot every reporting station by its lon/lat, colored by country
fig, ax = plt.subplots(figsize=(11, 5.5))

for country, group in df.groupby("country"):
    ax.scatter(group["longitude"], group["latitude"],
               s=6, alpha=0.6, label=country)

ax.set_title(f"Global METAR station coverage — {len(df)} stations, "
             f"only {df['country'].nunique()} countries", fontsize=13)
ax.set_xlabel("Longitude")
ax.set_ylabel("Latitude")
ax.set_xlim(-180, 180)
ax.set_ylim(-90, 90)
ax.axhline(0, color="gray", lw=0.4)   # equator reference line
ax.axvline(0, color="gray", lw=0.4)   # prime meridian reference line
ax.grid(True, linewidth=0.3, alpha=0.4)
ax.legend(title="Country", bbox_to_anchor=(1.01, 1), loc="upper left",
          fontsize=7, ncol=1)
plt.tight_layout()
plt.show()

import sys, subprocess
subprocess.run([sys.executable, "-m", "pip", "install", "geodatasets", "--quiet"])
print("done")

import geopandas as gpd
import matplotlib.pyplot as plt
import geodatasets

# Load a world basemap via geodatasets
world = gpd.read_file(geodatasets.get_path("naturalearth.land"))

gdf = gpd.GeoDataFrame(
    df, geometry=gpd.points_from_xy(df["longitude"], df["latitude"]), crs="EPSG:4326"
)

fig, ax = plt.subplots(figsize=(12, 6))
world.plot(ax=ax, color="#eeeeee", edgecolor="#cccccc", linewidth=0.5)
gdf.plot(ax=ax, markersize=4, color="#d9534f", alpha=0.5)
ax.set_title(f"Global METAR station coverage — {len(df)} stations, "
             f"only {df['country'].nunique()} countries", fontsize=13)
ax.set_xlabel("Longitude"); ax.set_ylabel("Latitude")
ax.set_xlim(-180, 180); ax.set_ylim(-90, 90)
plt.tight_layout()
plt.show()

# Demonstrate honest handling of missing data:
# query a station/time unlikely to have data, and show the assistant does NOT fabricate.

obs_missing = None  # simulate "no observation found"
print(generate_guidance_rule_based(obs_missing))
print("\n" + "="*50 + "\n")

# Also show partial data: temperature present, wind missing
obs_partial = {
    "station": "TEST", "name": "Example Ranch", "country": "US",
    "time": "2026-01-01 00:00", "temp_f": 28.0,
    "dewpoint_f": None, "wind_kt": None, "precip_in": None
}
print(generate_guidance_rule_based(obs_partial))