Add Python utilities and usage examples

examples.py

@@ -0,0 +1,265 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Example usage of the Weather Geo ERA5 Dataset
+
+This script demonstrates how to use the weather_geo_utils module to load
+and analyze weather data from the HuggingFace dataset.
+
+Requirements:
+    pip install pandas huggingface-hub matplotlib seaborn
+"""
+
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+from weather_geo_utils import (
+    load_point_data, 
+    load_cities_data, 
+    convert_temperature_units,
+    get_dataset_info
+)
+
+def example_single_city():
+    """Example: Load data for a single city (Paris)."""
+    print("=" * 60)
+    print("EXAMPLE 1: Single City Analysis (Paris)")
+    print("=" * 60)
+    
+    # Load 2023 data for Paris
+    print("Loading Paris weather data for 2023...")
+    df = load_point_data(
+        lat=48.8566, 
+        lon=2.3522, 
+        start_date="2023-01-01", 
+        end_date="2023-12-31"
+    )
+    
+    # Convert temperatures to Celsius
+    df = convert_temperature_units(df, from_unit='K', to_unit='C')
+    
+    print(f"Loaded {len(df)} records")
+    print(f"Date range: {df['time'].min()} to {df['time'].max()}")
+    print(f"Temperature range: {df['t2m'].min():.1f}°C to {df['t2m'].max():.1f}°C")
+    print(f"Average temperature: {df['t2m'].mean():.1f}°C")
+    
+    # Plot temperature timeline
+    plt.figure(figsize=(12, 6))
+    plt.plot(df['time'], df['t2m'], linewidth=0.5, alpha=0.7)
+    plt.title('Paris Temperature 2023')
+    plt.xlabel('Date')
+    plt.ylabel('Temperature (°C)')
+    plt.grid(True, alpha=0.3)
+    plt.tight_layout()
+    plt.savefig('paris_temperature_2023.png', dpi=300, bbox_inches='tight')
+    plt.show()
+    
+    return df
+
+def example_multiple_cities():
+    """Example: Compare multiple European cities."""
+    print("\n" + "=" * 60)
+    print("EXAMPLE 2: Multiple Cities Comparison")
+    print("=" * 60)
+    
+    # Define cities
+    cities = [
+        (48.8566, 2.3522, "Paris"),
+        (51.5074, -0.1278, "London"),
+        (52.5200, 13.4050, "Berlin"),
+        (41.9028, 12.4964, "Rome"),
+        (59.3293, 18.0686, "Stockholm"),
+    ]
+    
+    print(f"Loading data for {len(cities)} cities...")
+    
+    # Load 2023 data for all cities
+    df = load_cities_data(cities, start_date="2023-01-01", end_date="2023-12-31")
+    
+    # Convert temperatures to Celsius
+    df = convert_temperature_units(df, from_unit='K', to_unit='C')
+    
+    print(f"Total records loaded: {len(df)}")
+    
+    # Calculate monthly averages
+    df['month'] = df['time'].dt.month
+    monthly_temps = df.groupby(['city', 'month'])['t2m'].mean().reset_index()
+    monthly_temps['month_name'] = pd.to_datetime(monthly_temps['month'], format='%m').dt.strftime('%b')
+    
+    # Plot comparison
+    plt.figure(figsize=(12, 8))
+    
+    # Temperature comparison
+    plt.subplot(2, 1, 1)
+    for city in df['city'].unique():
+        city_data = monthly_temps[monthly_temps['city'] == city]
+        plt.plot(city_data['month'], city_data['t2m'], marker='o', label=city, linewidth=2)
+    
+    plt.title('Monthly Average Temperature Comparison 2023')
+    plt.xlabel('Month')
+    plt.ylabel('Temperature (°C)')
+    plt.legend()
+    plt.grid(True, alpha=0.3)
+    plt.xticks(range(1, 13), ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
+                              'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'])
+    
+    # Annual statistics
+    plt.subplot(2, 1, 2)
+    annual_stats = df.groupby('city')['t2m'].agg(['mean', 'min', 'max']).reset_index()
+    
+    x = range(len(annual_stats))
+    plt.bar(x, annual_stats['mean'], alpha=0.7, label='Average')
+    plt.errorbar(x, annual_stats['mean'], 
+                yerr=[annual_stats['mean'] - annual_stats['min'],
+                      annual_stats['max'] - annual_stats['mean']], 
+                fmt='none', color='black', capsize=5, alpha=0.8)
+    
+    plt.title('Annual Temperature Statistics 2023')
+    plt.xlabel('City')
+    plt.ylabel('Temperature (°C)')
+    plt.xticks(x, annual_stats['city'], rotation=45)
+    plt.grid(True, alpha=0.3)
+    
+    plt.tight_layout()
+    plt.savefig('cities_temperature_comparison.png', dpi=300, bbox_inches='tight')
+    plt.show()
+    
+    # Print summary statistics
+    print("\nAnnual Temperature Summary (°C):")
+    print(annual_stats.round(1))
+    
+    return df
+
+def example_climate_analysis():
+    """Example: Long-term climate analysis."""
+    print("\n" + "=" * 60)
+    print("EXAMPLE 3: Long-term Climate Analysis (Paris)")
+    print("=" * 60)
+    
+    print("Loading historical data for Paris (1980-2023)...")
+    df = load_point_data(
+        lat=48.8566, 
+        lon=2.3522, 
+        start_date="1980-01-01", 
+        end_date="2023-12-31"
+    )
+    
+    # Convert temperatures to Celsius
+    df = convert_temperature_units(df, from_unit='K', to_unit='C')
+    
+    print(f"Loaded {len(df)} records over {df['time'].dt.year.nunique()} years")
+    
+    # Calculate annual averages
+    df['year'] = df['time'].dt.year
+    annual_temps = df.groupby('year')['t2m'].mean().reset_index()
+    
+    # Plot long-term trend
+    plt.figure(figsize=(14, 10))
+    
+    # Annual temperature trend
+    plt.subplot(2, 2, 1)
+    plt.plot(annual_temps['year'], annual_temps['t2m'], linewidth=1, alpha=0.7)
+    
+    # Add trend line
+    from numpy.polynomial import Polynomial
+    p = Polynomial.fit(annual_temps['year'], annual_temps['t2m'], 1)
+    plt.plot(annual_temps['year'], p(annual_temps['year']), 'r--', linewidth=2, label='Trend')
+    
+    plt.title('Annual Average Temperature (Paris)')
+    plt.xlabel('Year')
+    plt.ylabel('Temperature (°C)')
+    plt.legend()
+    plt.grid(True, alpha=0.3)
+    
+    # Monthly climatology
+    plt.subplot(2, 2, 2)
+    df['month'] = df['time'].dt.month
+    monthly_climate = df.groupby('month')['t2m'].agg(['mean', 'std']).reset_index()
+    
+    plt.plot(monthly_climate['month'], monthly_climate['mean'], 'b-', linewidth=2, label='Average')
+    plt.fill_between(monthly_climate['month'], 
+                     monthly_climate['mean'] - monthly_climate['std'],
+                     monthly_climate['mean'] + monthly_climate['std'],
+                     alpha=0.3, label='±1 std dev')
+    
+    plt.title('Monthly Temperature Climatology')
+    plt.xlabel('Month')
+    plt.ylabel('Temperature (°C)')
+    plt.legend()
+    plt.grid(True, alpha=0.3)
+    plt.xticks(range(1, 13), ['J', 'F', 'M', 'A', 'M', 'J',
+                              'J', 'A', 'S', 'O', 'N', 'D'])
+    
+    # Temperature distribution
+    plt.subplot(2, 2, 3)
+    plt.hist(df['t2m'], bins=50, alpha=0.7, density=True)
+    plt.axvline(df['t2m'].mean(), color='red', linestyle='--', linewidth=2, label=f'Mean: {df["t2m"].mean():.1f}°C')
+    plt.title('Temperature Distribution')
+    plt.xlabel('Temperature (°C)')
+    plt.ylabel('Density')
+    plt.legend()
+    plt.grid(True, alpha=0.3)
+    
+    # Decade comparison
+    plt.subplot(2, 2, 4)
+    df['decade'] = (df['year'] // 10) * 10
+    decade_temps = df.groupby('decade')['t2m'].mean().reset_index()
+    
+    plt.bar(decade_temps['decade'], decade_temps['t2m'], width=8, alpha=0.7)
+    plt.title('Average Temperature by Decade')
+    plt.xlabel('Decade')
+    plt.ylabel('Temperature (°C)')
+    plt.grid(True, alpha=0.3)
+    
+    plt.tight_layout()
+    plt.savefig('paris_climate_analysis.png', dpi=300, bbox_inches='tight')
+    plt.show()
+    
+    # Calculate warming trend
+    warming_rate = p.coef[1]  # Slope of trend line
+    total_warming = warming_rate * (annual_temps['year'].max() - annual_temps['year'].min())
+    
+    print(f"\nClimate Analysis Results:")
+    print(f"Period: {annual_temps['year'].min()}-{annual_temps['year'].max()}")
+    print(f"Average temperature: {df['t2m'].mean():.1f}°C")
+    print(f"Warming rate: {warming_rate:.3f}°C/year")
+    print(f"Total warming: {total_warming:.1f}°C over {annual_temps['year'].max() - annual_temps['year'].min()} years")
+    
+    return df
+
+def main():
+    """Run all examples."""
+    print("Weather Geo ERA5 Dataset - Example Usage")
+    print("=" * 60)
+    
+    # Display dataset info
+    info = get_dataset_info()
+    print("Dataset Information:")
+    for key, value in info.items():
+        print(f"  {key}: {value}")
+    
+    try:
+        # Example 1: Single city
+        df1 = example_single_city()
+        
+        # Example 2: Multiple cities
+        df2 = example_multiple_cities()
+        
+        # Example 3: Climate analysis
+        df3 = example_climate_analysis()
+        
+        print("\n" + "=" * 60)
+        print("All examples completed successfully!")
+        print("Generated plots:")
+        print("  - paris_temperature_2023.png")
+        print("  - cities_temperature_comparison.png") 
+        print("  - paris_climate_analysis.png")
+        print("=" * 60)
+        
+    except Exception as e:
+        print(f"\nError running examples: {e}")
+        print("Make sure you have installed the required packages:")
+        print("  pip install pandas huggingface-hub matplotlib seaborn")
+
+if __name__ == "__main__":
+    main()

weather_geo_utils.py

@@ -0,0 +1,380 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Weather Geo ERA5 Dataset Utilities
+
+Helper functions for working with the geographically partitioned ERA5 weather dataset.
+This module provides convenient access patterns for the HuggingFace hosted dataset.
+
+Dataset: https://huggingface.co/datasets/NaaVrug/weather-geo-era5
+License: CC-BY-4.0
+Attribution: Contains modified Copernicus Climate Change Service information 2024
+"""
+
+import pandas as pd
+from pathlib import Path
+from typing import List, Tuple, Optional, Union
+from datetime import datetime, date
+import warnings
+
+try:
+    from huggingface_hub import hf_hub_download
+    HF_AVAILABLE = True
+except ImportError:
+    HF_AVAILABLE = False
+    warnings.warn("huggingface_hub not available. Install with: pip install huggingface-hub")
+
+# Dataset configuration
+REPO_ID = "NaaVrug/weather-geo-era5"
+REPO_TYPE = "dataset"
+
+# Geographic constants (30° lat × 45° lon tiles)
+LAT_BANDS = [
+    ("m90_m60", -90, -60),   # Antarctic
+    ("m60_m30", -60, -30),   # Southern mid-latitudes  
+    ("m30_p00", -30, 0),     # Southern tropics
+    ("p00_p30", 0, 30),      # Northern tropics
+    ("p30_p60", 30, 60),     # Northern mid-latitudes
+    ("p60_p90", 60, 90),     # Arctic
+]
+
+LON_BANDS = [
+    ("000_045", 0, 45),      # Europe/Africa West
+    ("045_090", 45, 90),     # Middle East/Central Asia
+    ("090_135", 90, 135),    # East Asia
+    ("135_180", 135, 180),   # Western Pacific
+    ("180_225", 180, 225),   # Central Pacific
+    ("225_270", 225, 270),   # Eastern Pacific
+    ("270_315", 270, 315),   # Americas West
+    ("315_360", 315, 360),   # Americas East/Atlantic
+]
+
+def get_tile_name(lat: float, lon: float) -> str:
+    """
+    Get the tile filename for given coordinates.
+    
+    Args:
+        lat: Latitude in degrees (-90 to 90)
+        lon: Longitude in degrees (-180 to 180 or 0 to 360)
+        
+    Returns:
+        Tile filename (e.g., "lat_p30_p60__lon_000_045.parquet")
+        
+    Examples:
+        >>> get_tile_name(48.8566, 2.3522)   # Paris
+        'lat_p30_p60__lon_000_045.parquet'
+        >>> get_tile_name(40.7128, -74.0060)  # NYC
+        'lat_p30_p60__lon_270_315.parquet'
+        >>> get_tile_name(-33.8688, 151.2093) # Sydney
+        'lat_m60_m30__lon_135_180.parquet'
+    """
+    # Validate inputs
+    if not -90 <= lat <= 90:
+        raise ValueError(f"Latitude must be between -90 and 90, got {lat}")
+    
+    # Normalize longitude to 0-360 range
+    lon = lon % 360
+    
+    # Find latitude band
+    lat_band = None
+    for band_name, lat_min, lat_max in LAT_BANDS:
+        if lat_min <= lat < lat_max or (lat == 90 and lat_max == 90):
+            lat_band = band_name
+            break
+    
+    if lat_band is None:
+        raise ValueError(f"Could not determine latitude band for {lat}")
+    
+    # Find longitude band
+    lon_band = None
+    for band_name, lon_min, lon_max in LON_BANDS:
+        if lon_min <= lon < lon_max or (lon == 360 and lon_max == 360):
+            lon_band = band_name
+            break
+    
+    if lon_band is None:
+        raise ValueError(f"Could not determine longitude band for {lon}")
+    
+    return f"lat_{lat_band}__lon_{lon_band}.parquet"
+
+def get_tiles_for_region(lat_min: float, lat_max: float, 
+                        lon_min: float, lon_max: float) -> List[str]:
+    """
+    Get all tile names that overlap with a rectangular region.
+    
+    Args:
+        lat_min, lat_max: Latitude bounds
+        lon_min, lon_max: Longitude bounds
+        
+    Returns:
+        List of tile filenames
+        
+    Example:
+        >>> # Europe region
+        >>> tiles = get_tiles_for_region(35, 70, -10, 40)
+        >>> print(len(tiles))  # Multiple tiles covering Europe
+    """
+    # Normalize longitude
+    lon_min = lon_min % 360
+    lon_max = lon_max % 360
+    
+    tiles = set()
+    
+    # Handle longitude wrap-around
+    if lon_min > lon_max:
+        # Region crosses 0° longitude
+        for lat_band_name, lat_band_min, lat_band_max in LAT_BANDS:
+            if not (lat_max < lat_band_min or lat_min >= lat_band_max):
+                for lon_band_name, lon_band_min, lon_band_max in LON_BANDS:
+                    if lon_band_min >= lon_min or lon_band_max <= lon_max:
+                        tiles.add(f"lat_{lat_band_name}__lon_{lon_band_name}.parquet")
+    else:
+        # Normal case
+        for lat_band_name, lat_band_min, lat_band_max in LAT_BANDS:
+            if not (lat_max < lat_band_min or lat_min >= lat_band_max):
+                for lon_band_name, lon_band_min, lon_band_max in LON_BANDS:
+                    if not (lon_max < lon_band_min or lon_min >= lon_band_max):
+                        tiles.add(f"lat_{lat_band_name}__lon_{lon_band_name}.parquet")
+    
+    return sorted(list(tiles))
+
+def load_point_data(lat: float, lon: float, 
+                   start_date: Optional[Union[str, date, datetime]] = None,
+                   end_date: Optional[Union[str, date, datetime]] = None,
+                   cache_dir: Optional[str] = None) -> pd.DataFrame:
+    """
+    Load weather data for a specific point.
+    
+    Args:
+        lat: Latitude in degrees
+        lon: Longitude in degrees  
+        start_date: Start date (YYYY-MM-DD or datetime object)
+        end_date: End date (YYYY-MM-DD or datetime object)
+        cache_dir: Local cache directory for downloaded files
+        
+    Returns:
+        DataFrame with weather data for the point
+        
+    Example:
+        >>> # Load 2020 data for Paris
+        >>> df = load_point_data(48.8566, 2.3522, "2020-01-01", "2020-12-31")
+        >>> print(f"Loaded {len(df)} records")
+    """
+    if not HF_AVAILABLE:
+        raise ImportError("huggingface_hub required. Install with: pip install huggingface-hub")
+    
+    # Get tile name
+    tile_name = get_tile_name(lat, lon)
+    
+    # Download tile
+    file_path = hf_hub_download(
+        repo_id=REPO_ID,
+        filename=f"tiles/{tile_name}",
+        repo_type=REPO_TYPE,
+        cache_dir=cache_dir
+    )
+    
+    # Load data
+    df = pd.read_parquet(file_path)
+    
+    # Filter for approximate coordinates (within 0.25° grid)
+    lat_tolerance = 0.125  # Half grid resolution
+    lon_tolerance = 0.125
+    
+    df = df[
+        (df['latitude'].between(lat - lat_tolerance, lat + lat_tolerance)) &
+        (df['longitude'].between(lon - lon_tolerance, lon + lon_tolerance))
+    ]
+    
+    # Filter by date range if specified
+    if start_date is not None:
+        df = df[df['time'] >= pd.to_datetime(start_date)]
+    if end_date is not None:
+        df = df[df['time'] <= pd.to_datetime(end_date)]
+    
+    return df.sort_values('time').reset_index(drop=True)
+
+def load_region_data(lat_min: float, lat_max: float,
+                    lon_min: float, lon_max: float,
+                    start_date: Optional[Union[str, date, datetime]] = None,
+                    end_date: Optional[Union[str, date, datetime]] = None,
+                    cache_dir: Optional[str] = None) -> pd.DataFrame:
+    """
+    Load weather data for a rectangular region.
+    
+    Args:
+        lat_min, lat_max: Latitude bounds
+        lon_min, lon_max: Longitude bounds
+        start_date: Start date filter
+        end_date: End date filter
+        cache_dir: Local cache directory
+        
+    Returns:
+        Combined DataFrame for the region
+        
+    Example:
+        >>> # Load data for a region around Paris
+        >>> df = load_region_data(48, 49, 2, 3, "2023-01-01", "2023-12-31")
+    """
+    if not HF_AVAILABLE:
+        raise ImportError("huggingface_hub required. Install with: pip install huggingface-hub")
+    
+    # Get all tiles covering the region
+    tiles = get_tiles_for_region(lat_min, lat_max, lon_min, lon_max)
+    
+    if not tiles:
+        raise ValueError(f"No tiles found for region: lat[{lat_min}, {lat_max}], lon[{lon_min}, {lon_max}]")
+    
+    print(f"Loading {len(tiles)} tiles for region...")
+    
+    dfs = []
+    for tile_name in tiles:
+        print(f"  Loading {tile_name}...")
+        
+        # Download tile
+        file_path = hf_hub_download(
+            repo_id=REPO_ID,
+            filename=f"tiles/{tile_name}",
+            repo_type=REPO_TYPE,
+            cache_dir=cache_dir
+        )
+        
+        # Load and filter data
+        df = pd.read_parquet(file_path)
+        
+        # Filter by geographic bounds
+        df = df[
+            (df['latitude'].between(lat_min, lat_max)) &
+            (df['longitude'].between(lon_min, lon_max))
+        ]
+        
+        # Filter by date range if specified
+        if start_date is not None:
+            df = df[df['time'] >= pd.to_datetime(start_date)]
+        if end_date is not None:
+            df = df[df['time'] <= pd.to_datetime(end_date)]
+        
+        if len(df) > 0:
+            dfs.append(df)
+    
+    if not dfs:
+        raise ValueError("No data found in the specified region and time range")
+    
+    # Combine all data
+    result = pd.concat(dfs, ignore_index=True)
+    return result.sort_values(['time', 'latitude', 'longitude']).reset_index(drop=True)
+
+def load_cities_data(cities: List[Tuple[float, float, str]],
+                    start_date: Optional[Union[str, date, datetime]] = None,
+                    end_date: Optional[Union[str, date, datetime]] = None,
+                    cache_dir: Optional[str] = None) -> pd.DataFrame:
+    """
+    Load weather data for multiple cities.
+    
+    Args:
+        cities: List of (lat, lon, name) tuples
+        start_date: Start date filter  
+        end_date: End date filter
+        cache_dir: Local cache directory
+        
+    Returns:
+        DataFrame with data for all cities, including 'city' column
+        
+    Example:
+        >>> cities = [
+        ...     (48.8566, 2.3522, "Paris"),
+        ...     (51.5074, -0.1278, "London"),
+        ...     (52.5200, 13.4050, "Berlin"),
+        ... ]
+        >>> df = load_cities_data(cities, "2023-01-01", "2023-12-31")
+    """
+    if not HF_AVAILABLE:
+        raise ImportError("huggingface_hub required. Install with: pip install huggingface-hub")
+    
+    dfs = []
+    for lat, lon, city_name in cities:
+        print(f"Loading data for {city_name}...")
+        
+        try:
+            df = load_point_data(lat, lon, start_date, end_date, cache_dir)
+            df['city'] = city_name
+            dfs.append(df)
+        except Exception as e:
+            print(f"  Warning: Failed to load data for {city_name}: {e}")
+    
+    if not dfs:
+        raise ValueError("No data loaded for any cities")
+    
+    return pd.concat(dfs, ignore_index=True)
+
+def convert_temperature_units(df: pd.DataFrame, 
+                            from_unit: str = 'K', 
+                            to_unit: str = 'C') -> pd.DataFrame:
+    """
+    Convert temperature units in the dataset.
+    
+    Args:
+        df: DataFrame with temperature columns
+        from_unit: Source unit ('K', 'C', 'F')
+        to_unit: Target unit ('K', 'C', 'F')
+        
+    Returns:
+        DataFrame with converted temperatures
+    """
+    df = df.copy()
+    temp_columns = ['t2m', 'd2m']
+    
+    for col in temp_columns:
+        if col in df.columns:
+            # Convert to Kelvin first
+            if from_unit == 'C':
+                temps_k = df[col] + 273.15
+            elif from_unit == 'F':
+                temps_k = (df[col] - 32) * 5/9 + 273.15
+            else:  # Assume Kelvin
+                temps_k = df[col]
+            
+            # Convert from Kelvin to target
+            if to_unit == 'C':
+                df[col] = temps_k - 273.15
+            elif to_unit == 'F':
+                df[col] = (temps_k - 273.15) * 9/5 + 32
+            else:  # Keep Kelvin
+                df[col] = temps_k
+    
+    return df
+
+def get_dataset_info() -> dict:
+    """Get information about the dataset."""
+    return {
+        "name": "Weather Geo ERA5 Dataset",
+        "repo_id": REPO_ID,
+        "url": f"https://huggingface.co/datasets/{REPO_ID}",
+        "license": "CC-BY-4.0",
+        "time_range": "1940-2024",
+        "resolution": "0.25° x 0.25°",
+        "total_tiles": len(LAT_BANDS) * len(LON_BANDS),
+        "variables": ["t2m", "tp", "d2m", "msl", "u10", "v10"],
+        "attribution": "Contains modified Copernicus Climate Change Service information 2024"
+    }
+
+# Example usage
+if __name__ == "__main__":
+    # Print dataset info
+    info = get_dataset_info()
+    print("Weather Geo ERA5 Dataset")
+    print("=" * 40)
+    for key, value in info.items():
+        print(f"{key}: {value}")
+    
+    print("\nExample tile names:")
+    cities = [
+        (48.8566, 2.3522, "Paris"),
+        (40.7128, -74.0060, "New York"),
+        (-33.8688, 151.2093, "Sydney"),
+        (35.6762, 139.6503, "Tokyo"),
+    ]
+    
+    for lat, lon, name in cities:
+        tile = get_tile_name(lat, lon)
+        print(f"  {name} ({lat:.4f}, {lon:.4f}): {tile}")