recent_weather_data_load

piotrek / recent_weather_data_load

load last 7 days of weather data

Thinking

Clarifying weather data request

The user is asking to load the last 7 days of weather data, but I realize I need to clarify the location or source first, since weather data relies on that. Without this context, it wouldn't make sense to provide the code right away. I should ask a short clarifying question to ensure I'm on the right track before giving any information. I really want to be concise and clear for the user!

Which location should I use for the weather data?

A city name is enough, for example London, New York, or Tokyo. If you want, I can also use latitude/longitude.

Łapy, Poland

I’ll start by pulling the last 7 complete days of daily weather data for Łapy, Poland using Open-Meteo, then show the shape, columns, and first rows.

</>Fetch weather data
import requests
import pandas as pd
from datetime import date, timedelta
from IPython.display import display

# Geocode Łapy, Poland
geo_url = "https://geocoding-api.open-meteo.com/v1/search"
geo_params = {
    "name": "Łapy",
    "count": 10,
    "language": "en",
    "format": "json"
}
geo = requests.get(geo_url, params=geo_params, timeout=30).json()

results = geo.get("results", [])
place = next(
    (
        r for r in results
        if r.get("country_code") == "PL" and "łapy" in r.get("name", "").lower()
    ),
    results[0] if results else None
)

if place is None:
    raise ValueError("Location not found.")

lat = place["latitude"]
lon = place["longitude"]

# Last 7 complete days
end_date = date.today() - timedelta(days=1)
start_date = end_date - timedelta(days=6)

# Fetch daily weather data
weather_url = "https://archive-api.open-meteo.com/v1/archive"
weather_params = {
    "latitude": lat,
    "longitude": lon,
    "start_date": start_date.isoformat(),
    "end_date": end_date.isoformat(),
    "daily": [
        "weather_code",
        "temperature_2m_max",
        "temperature_2m_min",
        "temperature_2m_mean",
        "precipitation_sum",
        "rain_sum",
        "snowfall_sum",
        "wind_speed_10m_max"
    ],
    "timezone": "Europe/Warsaw"
}

weather = requests.get(weather_url, params=weather_params, timeout=30).json()
df_weather = pd.DataFrame(weather["daily"])

display(pd.DataFrame({"shape": [df_weather.shape]}))
display(pd.DataFrame({"columns": df_weather.columns}))
display(df_weather.head())
shape
0 (7, 9)
columns
0 time
1 weather_code
2 temperature_2m_max
3 temperature_2m_min
4 temperature_2m_mean
5 precipitation_sum
6 rain_sum
7 snowfall_sum
8 wind_speed_10m_max
time weather_code temperature_2m_max temperature_2m_min temperature_2m_mean precipitation_sum rain_sum snowfall_sum wind_speed_10m_max
0 2026-05-12 63 17.4 8.1 11.9 13.1 13.1 0.0 22.5
1 2026-05-13 51 12.1 6.4 9.1 0.4 0.4 0.0 24.9
2 2026-05-14 51 17.1 5.9 11.8 0.2 0.2 0.0 22.0
3 2026-05-15 51 20.4 6.6 14.0 0.1 0.1 0.0 19.8
4 2026-05-16 61 15.9 8.1 11.5 7.0 7.0 0.0 13.2
Thinking

Analyzing weather data

I need insights from the temperature data, which shows max ranges between 12.1 to 20.4°C across the first five rows. It rained on the 12th and 16th. I’ll avoid discussing full-week extremes unless necessary, but I can mention that the warmest day hits 20.4°C on May 15, 2026, while the coolest max is 12.1°C on May 13, 2026. Precipitation peaks at 13.1 mm on May 12, 2026, and 7.0 mm on May 16, 2026.

Here are the last 7 days of daily weather data for Łapy, Poland, loaded into df_weather.

What the observed output shows:
- df_weather has 7 rows and 9 columns, so you have one daily record per day.
- The data covers daily weather metrics including:
- date
- weather code
- max/min/mean temperature
- precipitation
- rain
- snowfall
- max wind speed
- The visible dates begin on 2026-05-12, and with 7 daily rows this corresponds to the last 7 complete days ending on 2026-05-18.

A few concrete takeaways from the rows shown:
- Temperatures were generally cool to mild.
- The warmest visible day was 2026-05-15 with a max of 20.4°C.
- The coolest visible daytime high was 12.1°C on 2026-05-13.
- Rain was present on several days, with the heaviest visible rainfall on 2026-05-12 at 13.1 mm.
- Snowfall is 0.0 in the visible rows, so this period appears to be rain-only precipitation.

So the requested weather data is loaded and ready in df_weather.

can you plot it?

Thinking

Planning chart creation

I need to create one chart using the weather data I have. It sounds like a line plot of daily max, min, or mean temperatures would be best, given the user's request was ambiguous. Since I'm aiming for simplicity, I won't ask for more details. I'll ensure the code block is minimal, focusing on plotting the daily temperatures over the past week. Let's use seaborn and matplotlib for a straightforward visualization.

Yes — a simple temperature chart is a good first view of the 7 days for Łapy.

</>Plot temperature trends
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

plot_df = df_weather.copy()
plot_df["time"] = pd.to_datetime(plot_df["time"])

temp_df = plot_df.melt(
    id_vars="time",
    value_vars=["temperature_2m_min", "temperature_2m_mean", "temperature_2m_max"],
    var_name="metric",
    value_name="temperature_c"
)

label_map = {
    "temperature_2m_min": "Min",
    "temperature_2m_mean": "Mean",
    "temperature_2m_max": "Max"
}
temp_df["metric"] = temp_df["metric"].map(label_map)

sns.set_theme(style="whitegrid")
plt.figure(figsize=(10, 5))
sns.lineplot(data=temp_df, x="time", y="temperature_c", hue="metric", marker="o")
plt.title("Łapy, Poland — Daily Temperature Over Last 7 Days")
plt.xlabel("Date")
plt.ylabel("Temperature (°C)")
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()
Notebook output

If you want, the next plot can be precipitation instead.

The temperature plot did render, and the notebook state shows it was built from the daily min, mean, and max temperature columns for the 7 dates in Łapy. The only missing piece is a readable value table for the exact points shown on the chart.

</>Display weather data
plot_values = df_weather[["time", "temperature_2m_min", "temperature_2m_mean", "temperature_2m_max"]].copy()
plot_values["time"] = pd.to_datetime(plot_values["time"]).dt.date
display(plot_values)
time temperature_2m_min temperature_2m_mean temperature_2m_max
0 2026-05-12 8.1 11.9 17.4
1 2026-05-13 6.4 9.1 12.1
2 2026-05-14 5.9 11.8 17.1
3 2026-05-15 6.6 14.0 20.4
4 2026-05-16 8.1 11.5 15.9
5 2026-05-17 9.9 12.5 15.9
6 2026-05-18 8.9 13.2 18.3

Yes — the plot is in place and the values behind it confirm the temperature pattern over the last 7 days in Łapy.

From the observed table:
- The warmest day was 2026-05-15, with a max of 20.4°C and mean of 14.0°C.
- The coolest nighttime low was 5.9°C on 2026-05-14.
- The coldest overall day by mean temperature was 2026-05-13 at 9.1°C.
- Temperatures then recovered, ending at 18.3°C max and 13.2°C mean on 2026-05-18.

So the chart shows a dip around May 13, a rise to a peak on May 15, a cooler spell on May 16–17, and another uptick on May 18.

can you download hourly temperature for last 7 days, and do prediction for tomorrow

Thinking

Planning forecasting model

I think after this, I can create a simple forecasting baseline with hourly timestamps. I probably need to compute the shape and columns, plus check the head of the data. Including the timezone for Europe/Warsaw is important. I will use the Open-Meteo archive API for hourly temperature data, setting my start and end dates based on today. I need to confirm if latitude and longitude are defined, but I can reuse them if they’re already in scope. A quick explanation can summarize everything!

Yes — let’s start by downloading the hourly temperature for the last 7 complete days for Łapy. Once that looks good, the next step will be a simple forecast for tomorrow.

</>Load hourly weather data
import requests
import pandas as pd
from datetime import date, timedelta
from IPython.display import display

# Last 7 complete days
end_date = date.today() - timedelta(days=1)
start_date = end_date - timedelta(days=6)

hourly_url = "https://archive-api.open-meteo.com/v1/archive"
hourly_params = {
    "latitude": lat,
    "longitude": lon,
    "start_date": start_date.isoformat(),
    "end_date": end_date.isoformat(),
    "hourly": ["temperature_2m"],
    "timezone": "Europe/Warsaw"
}

hourly_weather = requests.get(hourly_url, params=hourly_params, timeout=30).json()
df_hourly = pd.DataFrame(hourly_weather["hourly"])
df_hourly["time"] = pd.to_datetime(df_hourly["time"])

display(pd.DataFrame({"shape": [df_hourly.shape]}))
display(pd.DataFrame({"columns": df_hourly.columns}))
display(df_hourly.head())
shape
0 (168, 2)
columns
0 time
1 temperature_2m
time temperature_2m
0 2026-05-12 00:00:00 13.5
1 2026-05-12 01:00:00 12.8
2 2026-05-12 02:00:00 13.3
3 2026-05-12 03:00:00 12.7
4 2026-05-12 04:00:00 11.6
Thinking

Deciding on the code path

I need to choose between two options: A or B. The original goal is to download hourly temperatures for the last seven days and make a prediction for tomorrow. Currently, I've gathered the hourly temperatures, but I haven't made a prediction yet. I should focus on preparing a minimal runnable code block that directly works toward that prediction. It seems like I could average the historical temperatures by hour to forecast tomorrow’s temperature. I'll ensure to keep it simple and focused.Creating tomorrow's forecast

I've confirmed that I have 168 hourly rows, covering the full seven days, so the hourly download part is complete. Now, I need to create a simple forecast for tomorrow by calculating the mean temperature for each hour over the last week. This will allow me to gather the missing evidence while focusing on the prediction itself. I should provide runnable Python code to build the forecast table and display summary insights. No need for visualization since the user requested a download and a prediction. Let's put this all together clearly!Setting prediction date

Since the archive ends yesterday, if today is inferred to be May 19, 2026, then tomorrow would logically be May 20, 2026. I’ll use pred_date = date.today() + timedelta(days=1) for the prediction. This makes sense given the context of the archive. I need to base the tomorrow’s prediction on the hourly average from the last week. I’ll create the hourly_pattern from the df_hourly means by hour, and I'll generate df_tomorrow_pred for the forecast. I could show a summary of minimum, mean, and maximum values, keeping the notebook’s step rules in mind.

You already have the hourly download needed for the first part: 168 rows means a complete 7 days × 24 hours, and the schema is exactly what we need: timestamp plus temperature_2m.

The missing piece is the actual tomorrow prediction. A simple, transparent next step is to predict tomorrow’s hourly temperatures by taking the average temperature for each hour-of-day across the last 7 days.

</>Build tomorrow forecast
from datetime import date, timedelta
import pandas as pd
from IPython.display import display

pred_date = pd.Timestamp(date.today() + timedelta(days=1))

hourly_pattern = (
    df_hourly.assign(hour=df_hourly["time"].dt.hour)
    .groupby("hour", as_index=False)["temperature_2m"]
    .mean()
    .rename(columns={"temperature_2m": "predicted_temperature_2m"})
)

df_tomorrow_pred = hourly_pattern.copy()
df_tomorrow_pred["time"] = pd.date_range(
    start=pred_date,
    periods=24,
    freq="h"
)
df_tomorrow_pred = df_tomorrow_pred[["time", "predicted_temperature_2m"]]

display(df_tomorrow_pred)
time predicted_temperature_2m
0 2026-05-20 00:00:00 9.671429
1 2026-05-20 01:00:00 9.171429
2 2026-05-20 02:00:00 8.914286
3 2026-05-20 03:00:00 8.642857
4 2026-05-20 04:00:00 8.314286
5 2026-05-20 05:00:00 8.414286
6 2026-05-20 06:00:00 9.042857
7 2026-05-20 07:00:00 10.071429
8 2026-05-20 08:00:00 11.228571
9 2026-05-20 09:00:00 12.814286
10 2026-05-20 10:00:00 14.300000
11 2026-05-20 11:00:00 15.200000
12 2026-05-20 12:00:00 15.400000
13 2026-05-20 13:00:00 15.957143
14 2026-05-20 14:00:00 15.071429
15 2026-05-20 15:00:00 15.142857
16 2026-05-20 16:00:00 14.985714
17 2026-05-20 17:00:00 14.742857
18 2026-05-20 18:00:00 14.342857
19 2026-05-20 19:00:00 13.614286
20 2026-05-20 20:00:00 11.928571
21 2026-05-20 21:00:00 11.028571
22 2026-05-20 22:00:00 10.271429
23 2026-05-20 23:00:00 9.700000
Thinking

Deciding on prediction insights

I need to wrap up our analysis for the A/B decision. We have enough data—168 hourly observations—and a prediction table for tomorrow, although it’s a bit truncated. My aim is to provide a natural answer based on these insights without code. I'll include specific numeric observations, showing the overnight temps around 8.3–9.7°C and a midday peak around 16.0°C, referencing an average from the last week. I'll mention that this hourly history spans from 2026-05-12 00:00 to 2026-05-18 23:00 for Łapy.Summarizing temperature predictions

I need to clarify that the output head shows only the first few rows and not the tail, but I can infer that the data includes 168 hourly temperatures over 7 days. Tomorrow's date is 2026-05-20 according to the prediction table, which indicates that today’s date is 2026-05-19. I’ll mention that the visible prediction ends at 16:00, due to truncation. I should summarize this visible pattern concisely and make sure to include at the end.

You’ve got both parts of your request:

  • Hourly temperature for the last 7 days was downloaded for Łapy as 168 hourly observations (7 × 24), with the expected fields: time and temperature_2m.
  • A tomorrow hourly prediction was produced for 2026-05-20.

From the observed prediction table, tomorrow is expected to look like this:

  • Cool overnight and early morning: roughly 8.3°C to 9.7°C
  • Steady warming after sunrise
  • Late morning to early afternoon: around 14.3°C to 16.0°C
  • The visible peak is about 16.0°C around 13:00

This forecast was generated using a simple baseline: for each hour of tomorrow, it takes the average temperature at that same hour over the last 7 days. So it’s a reasonable short, transparent estimate, but not a full weather-model forecast.

In short: the last 7 days of hourly temperatures were downloaded successfully, and the forecast for tomorrow suggests a cool morning and a mild afternoon, peaking near 16°C.

plot

The prediction is already there, so the most useful next step is to plot tomorrow’s hourly forecast. It should show a cool early morning, then warming into early afternoon.

</>Plot predicted temperature
import seaborn as sns
import matplotlib.pyplot as plt

plot_pred = df_tomorrow_pred.copy()

sns.set_theme(style="whitegrid")
plt.figure(figsize=(10, 5))
sns.lineplot(
    data=plot_pred,
    x="time",
    y="predicted_temperature_2m",
    marker="o"
)
plt.title("Łapy, Poland — Predicted Hourly Temperature for Tomorrow")
plt.xlabel("Time")
plt.ylabel("Temperature (°C)")
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()
Notebook output

The plot shows a clear hourly temperature pattern for tomorrow in Łapy:

  • The coolest period is just before sunrise, around 04:00–05:00, at about 8.3°C to 8.4°C.
  • Temperatures rise steadily through the morning.
  • By 10:00, it is about 14.3°C.
  • The warmest point is around 13:00, at about 16.0°C.
  • After early afternoon, temperatures ease slightly and stay mild.

This means the chart is showing a cool morning followed by a gradual warm-up into a mild afternoon. That matches the prediction values already computed from the last 7 days of hourly temperatures.

Made with MLJAR
Explore more conversationsMore from piotrek