weather_geo_utils.py

#!/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}")