Add tile uploader script

scripts/upload_tiles.py

@@ -0,0 +1,364 @@
+"""
+upload_tiles.py — Download JAXA AW3D30 tiles and upload to HuggingFace
+                   dataset MegaBites-AI/AW3D30-DEM-Tiles chunk by chunk.
+
+Usage:
+    python upload_tiles.py --region japan --token $HF_TOKEN
+    python upload_tiles.py --lat-range 30 45 --lon-range 130 145 --token $HF_TOKEN
+    python upload_tiles.py --all --token $HF_TOKEN   # WARNING: ~450 GB
+
+Tiles are downloaded from the JAXA open-access HTTP mirror, converted to
+compressed .npy arrays, and uploaded in configurable chunk sizes.
+"""
+
+import argparse
+import io
+import math
+import os
+import struct
+import sys
+import tempfile
+import time
+import zipfile
+from pathlib import Path
+from typing import Generator, List, Tuple
+
+import numpy as np
+import requests
+from huggingface_hub import HfApi
+
+# ---------------------------------------------------------------------------
+# Configuration
+# ---------------------------------------------------------------------------
+
+DATASET_REPO = "MegaBites-AI/AW3D30-DEM-Tiles"
+CHUNK_SIZE   = 10          # tiles per upload batch
+TILE_ROWS    = 3600
+TILE_COLS    = 3600
+NODATA_VAL   = -9999
+
+# JAXA open-access mirror (no login needed for AW3D30 v3.2)
+# Pattern: https://www.eorc.jaxa.jp/ALOS/aw3d30/data/release_v2303/
+#          {lat5_dir}/{tile}.zip   e.g. N030E135.zip
+JAXA_BASE = (
+    "https://www.eorc.jaxa.jp/ALOS/aw3d30/data/release_v2303"
+)
+
+# Known regional bounding boxes (lat_min, lat_max, lon_min, lon_max)
+REGIONS = {
+    "japan":         (24,  46, 122, 154),
+    "korea":         (33,  39, 124, 130),
+    "china":         (18,  53,  73, 135),
+    "south_asia":    ( 8,  37,  60,  97),
+    "southeast_asia":(-11, 28,  92, 141),
+    "australia":     (-44,  -9, 112, 154),
+    "europe":        (35,  72,  -25,  45),
+    "north_america": (15,  72, -170, -50),
+    "south_america": (-56,  13,  -82,  -34),
+    "africa":        (-35,  38,  -18,   52),
+    "global":        (-90,  90, -180,  180),
+}
+
+# ---------------------------------------------------------------------------
+# Tile enumeration
+# ---------------------------------------------------------------------------
+
+def tile_name(lat: int, lon: int) -> str:
+    lc = "N" if lat >= 0 else "S"
+    oc = "E" if lon >= 0 else "W"
+    return f"{lc}{abs(lat):03d}{oc}{abs(lon):03d}"
+
+
+def lat5_dir(lat: int) -> str:
+    """JAXA groups tiles in 5° latitude bands."""
+    base = (lat // 5) * 5
+    lc = "N" if base >= 0 else "S"
+    return f"{lc}{abs(base):03d}"
+
+
+def enumerate_tiles(
+    lat_min: int, lat_max: int,
+    lon_min: int, lon_max: int,
+) -> List[Tuple[int, int]]:
+    tiles = []
+    for lat in range(lat_min, lat_max):
+        for lon in range(lon_min, lon_max):
+            tiles.append((lat, lon))
+    return tiles
+
+
+def chunked(lst: list, n: int) -> Generator:
+    for i in range(0, len(lst), n):
+        yield lst[i:i + n]
+
+
+# ---------------------------------------------------------------------------
+# Download + decode
+# ---------------------------------------------------------------------------
+
+def download_tile(lat: int, lon: int, session: requests.Session) -> np.ndarray | None:
+    """
+    Download a JAXA AW3D30 tile and return it as a (3600,3600) int16 numpy array.
+    Returns None if tile doesn't exist (ocean / no data).
+    """
+    name  = tile_name(lat, lon)
+    lat5  = lat5_dir(lat)
+    url   = f"{JAXA_BASE}/{lat5}/{name}.zip"
+
+    try:
+        r = session.get(url, timeout=60, stream=True)
+        if r.status_code == 404:
+            return None
+        r.raise_for_status()
+    except requests.RequestException as e:
+        print(f"  [WARN] {name}: download failed — {e}")
+        return None
+
+    # The zip contains {name}/{name}_DSM.tif  (GeoTIFF)
+    # We'll decode the raw TIFF data without GDAL using basic struct parsing
+    raw = b"".join(r.iter_content(chunk_size=65536))
+    try:
+        with zipfile.ZipFile(io.BytesIO(raw)) as zf:
+            tif_name = next(
+                (n for n in zf.namelist() if n.endswith("_DSM.tif")), None
+            )
+            if tif_name is None:
+                print(f"  [WARN] {name}: no DSM.tif in zip")
+                return None
+            tif_data = zf.read(tif_name)
+    except zipfile.BadZipFile:
+        print(f"  [WARN] {name}: bad zip")
+        return None
+
+    arr = _parse_geotiff(tif_data, name)
+    return arr
+
+
+def _parse_geotiff(data: bytes, name: str) -> np.ndarray | None:
+    """
+    Minimal GeoTIFF parser that extracts the raw pixel data.
+    Works for stripped, uncompressed or LZW-compressed GeoTIFFs.
+    Falls back to numpy frombuffer for raw DEM files.
+    """
+    try:
+        # Try tifffile if available (optional dependency)
+        import tifffile
+        with tifffile.TiffFile(io.BytesIO(data)) as tif:
+            arr = tif.asarray()
+        if arr.ndim > 2:
+            arr = arr[0]
+        return arr.astype(np.int16)
+    except ImportError:
+        pass
+    except Exception as e:
+        print(f"  [WARN] {name}: tifffile parse error — {e}")
+
+    # Fallback: raw int16 row-major
+    expected = TILE_ROWS * TILE_COLS * 2  # int16 = 2 bytes
+    # scan for start of pixel data (after TIFF header)
+    if len(data) >= expected:
+        raw_pixels = data[-expected:]
+        arr = np.frombuffer(raw_pixels, dtype=">i2").reshape(TILE_ROWS, TILE_COLS)
+        return arr.astype(np.int16)
+
+    print(f"  [WARN] {name}: cannot parse TIFF, size={len(data)}")
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Upload to HuggingFace
+# ---------------------------------------------------------------------------
+
+def upload_chunk(
+    api: HfApi,
+    chunk: List[Tuple[int, int]],
+    session: requests.Session,
+    chunk_idx: int,
+    dry_run: bool = False,
+) -> Tuple[int, int]:
+    """Download and upload a chunk of tiles. Returns (ok, skipped)."""
+    ok = skipped = 0
+    operations = []
+
+    for lat, lon in chunk:
+        name = tile_name(lat, lon)
+        print(f"  ↓ Downloading {name} ...", end=" ", flush=True)
+        arr = download_tile(lat, lon, session)
+        if arr is None:
+            print("skip (no data)")
+            skipped += 1
+            continue
+
+        # Compress as .npy
+        buf = io.BytesIO()
+        np.save(buf, arr)
+        buf.seek(0)
+
+        lat_band = lat5_dir(lat)
+        hf_path = f"data/{lat_band}/{name}.npy"
+
+        if dry_run:
+            print(f"dry-run → {hf_path} ({arr.nbytes/1024:.0f} KB)")
+            ok += 1
+            continue
+
+        operations.append(
+            api.upload_file.__func__ if False else {
+                "path_or_fileobj": buf,
+                "path_in_repo": hf_path,
+            }
+        )
+
+        # Upload immediately per tile (streaming)
+        try:
+            api.upload_file(
+                path_or_fileobj=buf,
+                path_in_repo=hf_path,
+                repo_id=DATASET_REPO,
+                repo_type="dataset",
+                commit_message=f"Add tile {name}",
+            )
+            print(f"✓ {hf_path}")
+            ok += 1
+        except Exception as e:
+            print(f"✗ upload failed: {e}")
+            skipped += 1
+
+        time.sleep(0.3)  # be polite to HF API
+
+    return ok, skipped
+
+
+# ---------------------------------------------------------------------------
+# Dataset card
+# ---------------------------------------------------------------------------
+
+DATASET_CARD = """\
+---
+license: cc-by-4.0
+task_categories:
+- other
+language:
+- en
+tags:
+- elevation
+- dem
+- terrain
+- jaxa
+- aw3d30
+- geospatial
+- simulation
+- mskit
+pretty_name: JAXA AW3D30 30m DEM Tiles
+size_categories:
+- 10K<n<100K
+---
+
+# JAXA AW3D30 30m Digital Elevation Model — Tile Dataset
+
+Produced by **MegaBites AI** for use with **[MSKit](https://pypi.org/project/mskit/)** (Mini Simulation Kit).
+
+## About the data
+
+- **Source:** JAXA ALOS World 3D 30m (AW3D30) v3.2
+- **Resolution:** 30 metres/pixel
+- **Coverage:** Global (tiles available where JAXA data exists)
+- **Tile size:** 1°×1° → 3600×3600 pixels
+- **Format:** NumPy `.npy` files (int16, elevation in metres)
+- **NODATA:** -9999
+
+## File structure
+
+```
+data/
+  N000/
+    N000E000.npy
+    N000E001.npy
+    ...
+  N005/
+    ...
+```
+
+## Usage with MSKit
+
+```python
+from mskit import DEMLoader, RandomWalk
+
+loader = DEMLoader()                          # pulls tiles on demand
+rw = RandomWalk(loader, start_lat=35.6, start_lon=139.7)
+path = rw.run(steps=500)
+print(f"Walked {rw.total_distance_km():.2f} km, gain {rw.elevation_gain_m():.0f} m")
+```
+
+## License
+
+Original JAXA AW3D30 data: © JAXA, distributed under CC-BY-4.0.
+Dataset packaging: MegaBites AI Team.
+"""
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def main():
+    parser = argparse.ArgumentParser(description="Upload AW3D30 tiles to HuggingFace")
+    parser.add_argument("--token",      default=os.environ.get("HF_TOKEN"), help="HF token")
+    parser.add_argument("--region",     choices=list(REGIONS.keys()), help="Named region")
+    parser.add_argument("--lat-range",  nargs=2, type=int, metavar=("MIN", "MAX"))
+    parser.add_argument("--lon-range",  nargs=2, type=int, metavar=("MIN", "MAX"))
+    parser.add_argument("--chunk-size", type=int, default=CHUNK_SIZE)
+    parser.add_argument("--dry-run",    action="store_true")
+    parser.add_argument("--skip-card",  action="store_true")
+    args = parser.parse_args()
+
+    if not args.token:
+        sys.exit("Error: --token or HF_TOKEN env var required")
+
+    # Determine tile range
+    if args.region:
+        lat_min, lat_max, lon_min, lon_max = REGIONS[args.region]
+    elif args.lat_range and args.lon_range:
+        lat_min, lat_max = args.lat_range
+        lon_min, lon_max = args.lon_range
+    else:
+        parser.error("Specify --region or both --lat-range and --lon-range")
+
+    tiles = enumerate_tiles(lat_min, lat_max, lon_min, lon_max)
+    print(f"📦 {len(tiles)} tiles to process ({lat_min}–{lat_max}°N, {lon_min}–{lon_max}°E)")
+    print(f"📤 Target: {DATASET_REPO}")
+    print(f"🔢 Chunk size: {args.chunk_size}")
+    if args.dry_run:
+        print("🔍 DRY RUN — no uploads")
+
+    api = HfApi(token=args.token)
+
+    # Upload dataset card first
+    if not args.skip_card and not args.dry_run:
+        print("\n📝 Uploading dataset card...")
+        api.upload_file(
+            path_or_fileobj=DATASET_CARD.encode(),
+            path_in_repo="README.md",
+            repo_id=DATASET_REPO,
+            repo_type="dataset",
+            commit_message="Add dataset card",
+        )
+
+    session = requests.Session()
+    session.headers["User-Agent"] = "MSKit-tile-uploader/0.1"
+
+    total_ok = total_skip = 0
+    chunks = list(chunked(tiles, args.chunk_size))
+
+    for i, chunk in enumerate(chunks):
+        print(f"\n[Chunk {i+1}/{len(chunks)}]")
+        ok, skip = upload_chunk(api, chunk, session, i, dry_run=args.dry_run)
+        total_ok    += ok
+        total_skip  += skip
+        print(f"  → {ok} uploaded, {skip} skipped")
+
+    print(f"\n✅ Done! {total_ok} tiles uploaded, {total_skip} skipped.")
+
+
+if __name__ == "__main__":
+    main()