Upload folder using huggingface_hub

scripts/README.md

@@ -0,0 +1,52 @@
+# YFCC50K Photo Corpus Scripts
+
+Pipeline for curating, fetching, and uploading the Lightcella photo corpus
+from the YFCC100M dataset.
+
+## Pipeline
+
+### Step 1: Curate (`curate_manifest.py`)
+
+Selects 50k photos from YFCC100M with date/GPS/resolution stratification.
+
+Requires:
+- YFCC100M SQLite database (~65GB): `yfcc100m_dataset.sql`
+- MediaEval placing subset files (downloaded automatically via AWS CLI)
+- Python packages: `yfcc100m`, `opencv-python-headless`, `awscli`
+
+Three phases run sequentially:
+1. **Build metadata** -- scans YFCC SQLite for MediaEval placing hashes, extracts GPS/date/Flickr credentials
+2. **Select subset** -- stratified sampling by date, GPS, faces, resolution tiers
+3. **Upgrade resolution** -- probes Flickr for higher-res versions, assigns fetch tiers
+
+```bash
+python curate_manifest.py --db /path/to/yfcc100m_dataset.sql --out-dir ./output
+```
+
+Output: `manifest.tsv` (the same format shipped in this repo).
+
+### Step 2: Fetch (`fetch_flickr.py`)
+
+Downloads Flickr originals for manifest entries. Resumable, rate-limit aware.
+
+```bash
+python fetch_flickr.py --manifest manifest.tsv --out-dir ./photos
+```
+
+Features:
+- Classifies Flickr users as alive/dead/unsampled for efficient probing
+- Validates JPEG dimensions (skips <501px max edge)
+- Restores file mtime from manifest date (fallback for EXIF-less photos)
+- Automatic retry with backoff on 429s
+
+### Step 3: Upload (`upload_hf.py`)
+
+Creates ~1GB tar shards and uploads them to HuggingFace.
+
+```bash
+python upload_hf.py --src-dir ./photos --repo lightcella/photo-corpus --prefix yfcc
+```
+
+Features:
+- Resumable (skips already-uploaded shards)
+- Deletes local tar after successful upload to save disk

scripts/curate_manifest.py

@@ -0,0 +1,695 @@
+#!/usr/bin/env python3
+"""
+Curate a 50k YFCC subset for Lightcella testing.
+
+Three phases (run sequentially):
+  1. build-meta   -- Scan YFCC SQLite for MediaEval placing hashes, extract GPS/date/Flickr creds
+  2. select       -- Stratified sampling by date, GPS, faces, resolution tiers -> manifest
+  3. upgrade-res  -- Probe Flickr for higher-res versions, assign fetch tiers
+
+Requires:
+  - YFCC100M SQLite database (~65GB)
+  - Python packages: yfcc100m, opencv-python-headless, awscli
+  - MediaEval placing subset files (auto-downloaded from S3)
+
+Usage:
+  # Full pipeline:
+  python curate_manifest.py --db /path/to/yfcc100m_dataset.sql --out-dir ./output
+
+  # Individual phases:
+  python curate_manifest.py build-meta --db /path/to/yfcc100m_dataset.sql
+  python curate_manifest.py select --meta-jsonl placing_enriched.jsonl
+  python curate_manifest.py upgrade-res --db /path/to/yfcc100m_dataset.sql --manifest manifest.tsv
+"""
+
+from __future__ import annotations
+
+import argparse
+import bz2
+import csv
+import json
+import random
+import sqlite3
+import struct
+import subprocess
+import sys
+import time
+from collections import defaultdict
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+# ---------------------------------------------------------------------------
+# Shared utilities
+# ---------------------------------------------------------------------------
+
+S3_BUCKET = "multimedia-commons"
+PLACING_FILES = [
+    ("mediaeval2014_placing_test.bz2", "subsets/YLI-GEO/docs/mediaeval2014_placing_test.bz2"),
+    ("mediaeval2014_placing_train.bz2", "subsets/YLI-GEO/docs/mediaeval2014_placing_train.bz2"),
+]
+
+TIER_SMALL = "small"
+TIER_MEDIUM = "medium"
+TIER_LARGE = "large"
+DEFAULT_QUOTAS = {TIER_SMALL: 20000, TIER_MEDIUM: 15000, TIER_LARGE: 15000}
+
+
+def tier_from_max_edge(edge: int) -> str:
+    if edge > 1600:
+        return TIER_LARGE
+    elif edge > 800:
+        return TIER_MEDIUM
+    return TIER_SMALL
+
+
+def jpeg_dimensions(path: Path) -> tuple[int, int] | None:
+    try:
+        with open(path, "rb") as f:
+            data = f.read(64 * 1024)
+        i = 2
+        while i < len(data) - 9:
+            if data[i] != 0xFF:
+                break
+            marker = data[i + 1]
+            if marker in (0xC0, 0xC1, 0xC2):
+                h = struct.unpack(">H", data[i + 5 : i + 7])[0]
+                w = struct.unpack(">H", data[i + 7 : i + 9])[0]
+                return w, h
+            length = struct.unpack(">H", data[i + 2 : i + 4])[0]
+            i += 2 + length
+    except Exception:
+        pass
+    return None
+
+
+def yfcc_hash_fallback(url: str) -> str:
+    """Compute YFCC hash from download URL (md5 of URL path)."""
+    import hashlib
+    from urllib.parse import urlparse
+    path = urlparse(url).path
+    return hashlib.md5(path.encode()).hexdigest()
+
+
+def get_yfcc_hash():
+    """Try to import yfcc100m.convert_metadata.yfcc_hash, fallback to local."""
+    try:
+        from yfcc100m.convert_metadata import yfcc_hash
+        return yfcc_hash
+    except ImportError:
+        print("WARNING: yfcc100m not installed, using fallback hash", file=sys.stderr)
+        return yfcc_hash_fallback
+
+
+# ---------------------------------------------------------------------------
+# Phase 1: Build enriched metadata
+# ---------------------------------------------------------------------------
+
+def load_placing_hashes(cache_dir: Path) -> set[str]:
+    hashes: set[str] = set()
+    for name, s3_path in PLACING_FILES:
+        local = cache_dir / name
+        if not local.is_file():
+            subprocess.run(
+                [sys.executable, "-m", "awscli", "s3", "cp", "--no-sign-request",
+                 f"s3://{S3_BUCKET}/{s3_path}", str(local)],
+                check=True,
+            )
+        with bz2.open(local, "rt") as f:
+            for line in f:
+                h = line.split("\t", 1)[0].strip()
+                if len(h) == 32:
+                    hashes.add(h)
+    return hashes
+
+
+def cmd_build_meta(args) -> int:
+    """Phase 1: Scan YFCC SQLite for placing hashes, output enriched JSONL."""
+    cache_dir = args.cache_dir
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    out_path = args.out_dir / "placing_enriched.jsonl"
+
+    if not args.db.is_file():
+        print(f"Missing {args.db}; download from S3 first", file=sys.stderr)
+        return 1
+
+    yfcc_hash = get_yfcc_hash()
+    placing = load_placing_hashes(cache_dir)
+    print(f"Placing hashes: {len(placing):,}", flush=True)
+
+    conn = sqlite3.connect(str(args.db))
+    conn.execute("PRAGMA query_only = YES")
+    conn.execute("PRAGMA journal_mode = OFF")
+    cols = [c[0] for c in conn.execute("SELECT * FROM yfcc100m_dataset LIMIT 0").description]
+
+    found = 0
+    with out_path.open("w") as out:
+        cur = conn.execute("SELECT * FROM yfcc100m_dataset")
+        for i, row in enumerate(cur):
+            if i and i % 5_000_000 == 0:
+                print(f"  scanned {i:,} rows, matched {found:,}", flush=True)
+            d = dict(zip(cols, row))
+            url = d.get("downloadurl") or ""
+            if not url:
+                continue
+            key = yfcc_hash(url)
+            if key not in placing:
+                continue
+            lat, lon = d.get("latitude"), d.get("longitude")
+            if not lat or not lon:
+                continue
+            try:
+                lat_f, lon_f = float(lat), float(lon)
+            except ValueError:
+                continue
+            rec = {
+                "hash": key,
+                "photoid": d.get("photoid"),
+                "uid": d.get("uid"),
+                "datetaken": d.get("datetaken"),
+                "latitude": lat_f,
+                "longitude": lon_f,
+                "capturedevice": d.get("capturedevice") or "",
+                "ext": d.get("ext") or "jpg",
+                "serverid": d.get("serverid"),
+                "farmid": d.get("farmid"),
+                "secret": str(d.get("secret") or ""),
+                "secretoriginal": str(d.get("secretoriginal") or ""),
+                "downloadurl": d.get("downloadurl") or "",
+            }
+            out.write(json.dumps(rec) + "\n")
+            found += 1
+
+    print(f"Wrote {found:,} records to {out_path}", flush=True)
+    return 0
+
+
+# ---------------------------------------------------------------------------
+# Phase 2: Select subset
+# ---------------------------------------------------------------------------
+
+@dataclass
+class PhotoMeta:
+    hash: str
+    photoid: int = 0
+    uid: str = ""
+    date_iso: str = ""
+    lat: Optional[float] = None
+    lon: Optional[float] = None
+    has_gps: bool = False
+    has_face: bool = False
+    has_exif_thumb: bool = False
+    has_date: bool = False
+    trip_id: int = -1
+    ext: str = "jpg"
+    serverid: int = 0
+    farmid: int = 0
+    secret: str = ""
+    width: int = 0
+    height: int = 0
+    max_edge: int = 0
+    resolution_tier: str = "small"
+    fetch_source: str = "s3"
+    flickr_size: str = ""
+
+
+def parse_datetaken(s: str) -> str:
+    if not s:
+        return ""
+    s = str(s).strip()
+    try:
+        base = s.split(".", 1)[0] if "." in s else s[:19]
+        dt = datetime.strptime(base[:19], "%Y-%m-%d %H:%M:%S")
+        return dt.replace(tzinfo=timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    except ValueError:
+        return ""
+
+
+def load_enriched(path: Path) -> list[PhotoMeta]:
+    metas: list[PhotoMeta] = []
+    with path.open() as f:
+        for line in f:
+            d = json.loads(line)
+            m = PhotoMeta(
+                hash=d["hash"],
+                photoid=int(d.get("photoid") or 0),
+                uid=d.get("uid") or "",
+                lat=float(d["latitude"]),
+                lon=float(d["longitude"]),
+                has_gps=True,
+                ext=(d.get("ext") or "jpg").lower(),
+                serverid=int(d.get("serverid") or 0),
+                farmid=int(d.get("farmid") or 0),
+                secret=str(d.get("secret") or ""),
+            )
+            m.date_iso = parse_datetaken(d.get("datetaken", ""))
+            m.has_date = bool(m.date_iso)
+            metas.append(m)
+    return metas
+
+
+def assign_trips_by_uid(metas: list[PhotoMeta], min_len: int = 30) -> None:
+    """Cluster same Flickr user + time proximity + geo cell into trips."""
+    by_uid: dict[str, list[PhotoMeta]] = defaultdict(list)
+    for m in metas:
+        if m.has_date and m.has_gps and m.uid:
+            by_uid[m.uid].append(m)
+
+    tid = 0
+    for uid, photos in by_uid.items():
+        photos.sort(key=lambda x: x.date_iso)
+        current: list[PhotoMeta] = []
+        last_ts = 0.0
+        last_cell = ""
+
+        def cell(m: PhotoMeta) -> str:
+            return f"{int((m.lat + 90) * 50)}:{int((m.lon + 180) * 50)}"
+
+        def flush():
+            nonlocal tid, current
+            if len(current) >= min_len:
+                for p in current:
+                    p.trip_id = tid
+                tid += 1
+            current = []
+
+        for m in photos:
+            ts = datetime.strptime(m.date_iso, "%Y-%m-%dT%H:%M:%SZ").timestamp()
+            c = cell(m)
+            if current:
+                gap = (ts - last_ts) / 86400.0
+                if c != last_cell or gap > 21 or gap < -1:
+                    flush()
+            current.append(m)
+            last_ts = ts
+            last_cell = c
+        flush()
+
+
+def stratified_fill(selected: dict, rest: list, target: int, rng: random.Random):
+    """Fill remaining slots with date-stratified random sampling."""
+    rng.shuffle(rest)
+    for m in rest:
+        if len(selected) >= target:
+            break
+        if m.hash not in selected:
+            selected[m.hash] = m
+
+
+def select_final(metas: list[PhotoMeta], target: int, seed: int = 42) -> list[PhotoMeta]:
+    selected: dict[str, PhotoMeta] = {}
+
+    # Prioritize trip photos
+    trip_sorted = sorted(metas, key=lambda m: (m.trip_id < 0, -m.trip_id, m.date_iso))
+    for m in trip_sorted:
+        if m.trip_id >= 0 and len(selected) < target:
+            selected[m.hash] = m
+
+    # Fill with faces
+    for m in sorted(metas, key=lambda x: x.has_face, reverse=True):
+        if sum(1 for x in selected.values() if x.has_face) >= max(2500, int(target * 0.05)):
+            break
+        if len(selected) < target:
+            selected[m.hash] = m
+
+    # Fill rest randomly
+    rng = random.Random(seed)
+    rest = [m for m in metas if m.hash not in selected]
+    stratified_fill(selected, rest, target, rng)
+
+    return list(selected.values())
+
+
+def cmd_select(args) -> int:
+    """Phase 2: Select 50k subset from enriched metadata."""
+    if not args.meta_jsonl.is_file():
+        print(f"Missing {args.meta_jsonl}; run build-meta first", file=sys.stderr)
+        return 1
+
+    print("Loading enriched metadata ...", flush=True)
+    all_meta = load_enriched(args.meta_jsonl)
+    print(f"  pool: {len(all_meta):,} geotagged placing photos", flush=True)
+
+    all_meta.sort(key=lambda m: int(m.hash[:16], 16) ^ args.seed)
+    probe_pool = all_meta[: max(args.target * 2, len(all_meta))]
+
+    assign_trips_by_uid(probe_pool)
+    final = select_final(probe_pool, args.target, seed=args.seed)
+
+    if len(final) < args.target:
+        print(f"ERROR: selected {len(final)} < {args.target}", file=sys.stderr)
+        return 1
+
+    out_manifest = args.out_dir / "manifest.tsv"
+    args.out_dir.mkdir(parents=True, exist_ok=True)
+
+    with out_manifest.open("w", newline="") as f:
+        w = csv.writer(f, delimiter="\t")
+        w.writerow([
+            "hash", "date_iso", "lat", "lon", "has_gps", "has_face", "has_exif_thumb",
+            "trip_id", "uid", "photoid", "serverid", "secret",
+            "width", "height", "max_edge", "resolution_tier", "fetch_source", "flickr_size",
+        ])
+        for m in sorted(final, key=lambda x: (x.trip_id, x.date_iso, x.hash)):
+            w.writerow([
+                m.hash, m.date_iso,
+                f"{m.lat:.6f}" if m.lat is not None else "",
+                f"{m.lon:.6f}" if m.lon is not None else "",
+                int(m.has_gps), int(m.has_face), int(m.has_exif_thumb),
+                m.trip_id, m.uid, m.photoid, m.serverid, m.secret,
+                m.width, m.height, m.max_edge, m.resolution_tier, m.fetch_source, m.flickr_size,
+            ])
+
+    print(f"Wrote {len(final):,} entries to {out_manifest}")
+    return 0
+
+
+# ---------------------------------------------------------------------------
+# Phase 3: Upgrade resolution tiers
+# ---------------------------------------------------------------------------
+
+MANIFEST_HEADER = [
+    "hash", "date_iso", "lat", "lon", "has_gps", "has_face", "has_exif_thumb",
+    "trip_id", "uid", "photoid", "serverid", "secret",
+    "width", "height", "max_edge", "resolution_tier", "fetch_source", "flickr_size",
+]
+
+
+@dataclass
+class Row:
+    hash: str
+    date_iso: str = ""
+    lat: str = ""
+    lon: str = ""
+    has_gps: str = "1"
+    has_face: str = "0"
+    has_exif_thumb: str = "0"
+    trip_id: str = "-1"
+    uid: str = ""
+    photoid: int = 0
+    serverid: int = 0
+    secret: str = ""
+    width: int = 0
+    height: int = 0
+    max_edge: int = 0
+    resolution_tier: str = TIER_SMALL
+    fetch_source: str = "s3"
+    flickr_size: str = ""
+    s3_max_edge: int = 0
+    flickr_max_edge: int = 0
+
+    def to_manifest_row(self) -> list:
+        return [
+            self.hash, self.date_iso, self.lat, self.lon, self.has_gps,
+            self.has_face, self.has_exif_thumb, self.trip_id, self.uid,
+            self.photoid, self.serverid, self.secret, self.width, self.height,
+            self.max_edge, self.resolution_tier, self.fetch_source, self.flickr_size,
+        ]
+
+
+def load_manifest(path: Path) -> dict[str, Row]:
+    rows: dict[str, Row] = {}
+    with path.open(encoding="utf-8") as f:
+        reader = csv.DictReader(f, delimiter="\t")
+        for d in reader:
+            h = d["hash"]
+            rows[h] = Row(
+                hash=h,
+                date_iso=d.get("date_iso", ""),
+                lat=d.get("lat", ""),
+                lon=d.get("lon", ""),
+                has_gps=d.get("has_gps", "1"),
+                has_face=d.get("has_face", "0"),
+                has_exif_thumb=d.get("has_exif_thumb", "0"),
+                trip_id=d.get("trip_id", "-1"),
+                uid=d.get("uid", ""),
+                photoid=int(d.get("photoid") or 0),
+                serverid=int(d.get("serverid") or 0),
+                secret=d.get("secret") or "",
+            )
+    return rows
+
+
+def probe_best_flickr(serverid, photoid, secret, cache_dir: Path, h: str) -> tuple[int, str, Optional[Path]]:
+    """Probe Flickr for the best available size. Returns (max_edge, size_suffix, path)."""
+    sizes = ["o", "k", "b"]  # original, 2048, 1024
+    for size in sizes:
+        url = f"https://live.staticflickr.com/{serverid}/{photoid}_{secret}_{size}.jpg"
+        dest = cache_dir / f"{h}_{size}.jpg"
+        if dest.is_file() and dest.stat().st_size > 1000:
+            dims = jpeg_dimensions(dest)
+            if dims:
+                return max(dims), size, dest
+            continue
+        r = subprocess.run(
+            ["curl", "-sL", "-o", str(dest), "-w", "%{http_code}", url,
+             "--connect-timeout", "3", "--max-time", "8"],
+            capture_output=True, text=True, timeout=12,
+        )
+        if r.stdout.strip() == "200" and dest.is_file() and dest.stat().st_size > 1000:
+            dims = jpeg_dimensions(dest)
+            if dims:
+                return max(dims), size, dest
+        dest.unlink(missing_ok=True)
+    return 0, "", None
+
+
+def probe_row(row: Row, photos_dir: Path, cache_dir: Path, probe_flickr: bool) -> Row:
+    row.s3_max_edge = 0
+    p = photos_dir / f"{row.hash}.jpg"
+    if p.is_file():
+        dims = jpeg_dimensions(p)
+        if dims:
+            row.s3_max_edge = max(dims)
+            row.width, row.height = dims
+
+    row.max_edge = row.s3_max_edge
+    row.fetch_source = "s3"
+    row.flickr_max_edge = 0
+
+    if probe_flickr and row.photoid and row.serverid and row.secret:
+        flickr_edge, flickr_size, flickr_path = probe_best_flickr(
+            row.serverid, row.photoid, row.secret, cache_dir, row.hash
+        )
+        row.flickr_max_edge = flickr_edge
+        row.flickr_size = flickr_size
+        if flickr_edge > row.max_edge and flickr_path:
+            dims = jpeg_dimensions(flickr_path)
+            if dims:
+                row.width, row.height = dims
+                row.max_edge = max(dims)
+            else:
+                row.max_edge = flickr_edge
+
+    return row
+
+
+def assign_tiers(rows: list[Row], quotas: dict[str, int], seed: int) -> None:
+    """Assign fetch tier per hash based on available Flickr resolution."""
+    upgradable = [r for r in rows if r.flickr_max_edge > r.s3_max_edge and r.flickr_size]
+    upgradable.sort(key=lambda r: r.flickr_max_edge, reverse=True)
+
+    large_quota = quotas.get(TIER_LARGE, 0)
+    medium_quota = quotas.get(TIER_MEDIUM, 0)
+
+    large: list[Row] = []
+    medium: list[Row] = []
+    for r in upgradable:
+        if len(large) < large_quota and r.flickr_max_edge > 1600:
+            large.append(r)
+        elif len(medium) < medium_quota and r.flickr_max_edge > 500:
+            medium.append(r)
+        if len(large) >= large_quota and len(medium) >= medium_quota:
+            break
+
+    used = {r.hash for r in large + medium}
+    rest = [r for r in upgradable if r.hash not in used]
+    rng = random.Random(seed)
+    rng.shuffle(rest)
+    while len(large) < large_quota and rest:
+        large.append(rest.pop())
+    while len(medium) < medium_quota and rest:
+        medium.append(rest.pop())
+
+    for r in large:
+        r.resolution_tier = TIER_LARGE
+        r.fetch_source = "flickr"
+        r.max_edge = r.flickr_max_edge
+    for r in medium:
+        r.resolution_tier = TIER_MEDIUM
+        r.fetch_source = "flickr"
+        r.max_edge = r.flickr_max_edge
+    for r in rows:
+        if r.fetch_source == "s3":
+            r.resolution_tier = tier_from_max_edge(r.s3_max_edge or 500)
+            r.max_edge = r.s3_max_edge or 500
+
+
+def join_flickr_metadata(rows: dict[str, Row], db_path: Path, cache_path: Optional[Path] = None) -> int:
+    """Join manifest hashes against YFCC SQLite for Flickr credentials."""
+    yfcc_hash = get_yfcc_hash()
+    want = set(rows)
+
+    if cache_path and cache_path.is_file():
+        cached = json.loads(cache_path.read_text())
+        hit = 0
+        for h, meta in cached.items():
+            if h not in rows:
+                continue
+            row = rows[h]
+            row.photoid = int(meta.get("photoid") or 0)
+            row.serverid = int(meta.get("serverid") or 0)
+            row.secret = str(meta.get("secret") or "")
+            hit += 1
+        print(f"  loaded {hit:,} Flickr credentials from cache", flush=True)
+        return hit
+
+    found_meta: dict[str, dict] = {}
+    conn = sqlite3.connect(str(db_path))
+    conn.execute("PRAGMA query_only = ON")
+    conn.execute("PRAGMA journal_mode = OFF")
+    cur = conn.execute("SELECT downloadurl, photoid, serverid, secret FROM yfcc100m_dataset")
+    for i, raw in enumerate(cur, 1):
+        if i % 5_000_000 == 0:
+            print(f"  SQL scan {i:,} rows, matched {len(found_meta):,}", flush=True)
+        url = raw[0]
+        if not url:
+            continue
+        key = yfcc_hash(url)
+        if key not in want:
+            continue
+        found_meta[key] = {"photoid": raw[1], "serverid": raw[2], "secret": raw[3] or ""}
+        if len(found_meta) >= len(want):
+            break
+    conn.close()
+
+    for h, meta in found_meta.items():
+        row = rows[h]
+        row.photoid = int(meta.get("photoid") or 0)
+        row.serverid = int(meta.get("serverid") or 0)
+        row.secret = str(meta.get("secret") or "")
+
+    if cache_path:
+        cache_path.parent.mkdir(parents=True, exist_ok=True)
+        cache_path.write_text(json.dumps(found_meta))
+
+    return len(found_meta)
+
+
+def cmd_upgrade_res(args) -> int:
+    """Phase 3: Probe Flickr for higher resolution, assign tiers."""
+    if not args.db.is_file():
+        print(f"Missing {args.db}", file=sys.stderr)
+        return 1
+
+    manifest_path = args.manifest
+    if not manifest_path.is_file():
+        print(f"Missing {manifest_path}; run select first", file=sys.stderr)
+        return 1
+
+    quotas = {}
+    for part in args.resolution_quotas.split(","):
+        tier, count = part.split("=", 1)
+        quotas[tier.strip()] = int(count)
+
+    print("Loading manifest ...", flush=True)
+    rows = load_manifest(manifest_path)
+    print(f"  {len(rows):,} hashes", flush=True)
+
+    print("Joining Flickr metadata from SQL ...", flush=True)
+    cache_path = args.cache_dir / "flickr_meta_cache.json"
+    matched = join_flickr_metadata(rows, args.db, cache_path)
+    print(f"  matched {matched:,}/{len(rows):,}", flush=True)
+
+    work = list(rows.values())
+    if args.limit:
+        work = work[:args.limit]
+
+    args.cache_dir.mkdir(parents=True, exist_ok=True)
+    photos_dir = args.photos_dir
+    photos_dir.mkdir(parents=True, exist_ok=True)
+
+    print(f"Probing dimensions ({len(work):,} files, {args.workers} workers) ...", flush=True)
+    t0 = time.time()
+    with ThreadPoolExecutor(max_workers=max(1, args.workers)) as ex:
+        futs = [
+            ex.submit(probe_row, row, photos_dir, args.cache_dir, not args.skip_flickr_probe)
+            for row in work
+        ]
+        for i, fut in enumerate(as_completed(futs), 1):
+            fut.result()
+            if i % 2000 == 0:
+                print(f"  {i:,}/{len(work):,} ({i/(time.time()-t0):.1f}/s)", flush=True)
+
+    assign_tiers(work, quotas, args.seed)
+
+    # Write updated manifest
+    with manifest_path.open("w", newline="") as f:
+        w = csv.writer(f, delimiter="\t")
+        w.writerow(MANIFEST_HEADER)
+        for r in sorted(work, key=lambda x: (x.trip_id, x.date_iso, x.hash)):
+            w.writerow(r.to_manifest_row())
+
+    tier_counts = defaultdict(int)
+    for r in work:
+        tier_counts[r.resolution_tier] += 1
+
+    print(f"Wrote {manifest_path}")
+    print(f"  small={tier_counts[TIER_SMALL]} medium={tier_counts[TIER_MEDIUM]} large={tier_counts[TIER_LARGE]}")
+    return 0
+
+
+# ---------------------------------------------------------------------------
+# Main CLI
+# ---------------------------------------------------------------------------
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Curate YFCC50K manifest for Lightcella photo corpus",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__,
+    )
+    sub = parser.add_subparsers(dest="command")
+
+    # build-meta
+    p1 = sub.add_parser("build-meta", help="Phase 1: extract placing metadata from YFCC SQLite")
+    p1.add_argument("--db", type=Path, required=True, help="Path to yfcc100m_dataset.sql")
+    p1.add_argument("--cache-dir", type=Path, default=Path("cache"), help="Dir for S3 downloads")
+    p1.add_argument("--out-dir", type=Path, default=Path("."), help="Output directory")
+
+    # select
+    p2 = sub.add_parser("select", help="Phase 2: stratified subset selection")
+    p2.add_argument("--meta-jsonl", type=Path, default=Path("placing_enriched.jsonl"))
+    p2.add_argument("--out-dir", type=Path, default=Path("."))
+    p2.add_argument("--target", type=int, default=50000)
+    p2.add_argument("--seed", type=int, default=42)
+
+    # upgrade-res
+    p3 = sub.add_parser("upgrade-res", help="Phase 3: probe Flickr, assign resolution tiers")
+    p3.add_argument("--db", type=Path, required=True, help="Path to yfcc100m_dataset.sql")
+    p3.add_argument("--manifest", type=Path, default=Path("manifest.tsv"))
+    p3.add_argument("--photos-dir", type=Path, default=Path("photos"))
+    p3.add_argument("--cache-dir", type=Path, default=Path("cache"))
+    p3.add_argument("--workers", type=int, default=32)
+    p3.add_argument("--limit", type=int, default=0)
+    p3.add_argument("--skip-flickr-probe", action="store_true")
+    p3.add_argument("--resolution-quotas", default="small=20000,medium=15000,large=15000")
+    p3.add_argument("--seed", type=int, default=42)
+
+    args = parser.parse_args()
+
+    if args.command == "build-meta":
+        return cmd_build_meta(args)
+    elif args.command == "select":
+        return cmd_select(args)
+    elif args.command == "upgrade-res":
+        return cmd_upgrade_res(args)
+    else:
+        parser.print_help()
+        return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/fetch_flickr.py

@@ -0,0 +1,287 @@
+#!/usr/bin/env python3
+"""
+Fetch Flickr _o originals for YFCC photos by tier.
+Downloads only if >500px max edge. Resumable -- skips existing files and known-dead hashes.
+Prioritizes known-alive users (fast), probes unsampled users, defers dead users.
+"""
+import csv
+import json
+import os
+import struct
+import subprocess
+import sys
+import time
+from collections import defaultdict
+from pathlib import Path
+
+MIN_EDGE = 501
+
+
+def jpeg_dimensions(path: Path) -> tuple[int, int] | None:
+    try:
+        with open(path, "rb") as f:
+            data = f.read(64 * 1024)
+        i = 2
+        while i < len(data) - 9:
+            if data[i] != 0xFF:
+                break
+            marker = data[i + 1]
+            if marker in (0xC0, 0xC1, 0xC2):
+                h = struct.unpack(">H", data[i + 5 : i + 7])[0]
+                w = struct.unpack(">H", data[i + 7 : i + 9])[0]
+                return w, h
+            length = struct.unpack(">H", data[i + 2 : i + 4])[0]
+            i += 2 + length
+    except Exception:
+        pass
+    return None
+
+
+def restore_mtime(dest: Path, date_iso: str) -> None:
+    """Set file mtime from manifest date so Lightcella uses it as fallback."""
+    if not date_iso:
+        return
+    try:
+        from datetime import datetime
+        dt = datetime.fromisoformat(date_iso.replace("Z", "+00:00"))
+        ts = dt.timestamp()
+        if ts > 0:
+            os.utime(dest, (ts, ts))
+    except (ValueError, OSError):
+        pass
+
+
+def fetch_one(row: dict, out_dir: Path) -> tuple[str, dict | None]:
+    """Returns (status, result). status: 'ok', 'small', 'dead', 'rate_limited'."""
+    h = row["hash"]
+    dest = out_dir / f"{h}.jpg"
+
+    if dest.is_file() and dest.stat().st_size > 0:
+        dims = jpeg_dimensions(dest)
+        if dims and max(dims) >= MIN_EDGE:
+            return "ok", {"hash": h, "width": dims[0], "height": dims[1]}
+        return "small", None
+
+    sid, pid, sec = row["serverid"], row["photoid"], row["secret"]
+    url = f"https://live.staticflickr.com/{sid}/{pid}_{sec}_o.jpg"
+
+    r = subprocess.run(
+        ["curl", "-sL", "-o", str(dest), "-w", "%{http_code}", url,
+         "--connect-timeout", "3", "--max-time", "10"],
+        capture_output=True, text=True, timeout=15,
+    )
+    http_code = r.stdout.strip()
+
+    if http_code == "429":
+        dest.unlink(missing_ok=True)
+        return "rate_limited", None
+
+    if r.returncode != 0 or not dest.is_file() or dest.stat().st_size < 1000:
+        dest.unlink(missing_ok=True)
+        return "dead", None
+
+    dims = jpeg_dimensions(dest)
+    if not dims or max(dims) < MIN_EDGE:
+        dest.unlink(missing_ok=True)
+        return "small", None
+
+    restore_mtime(dest, row.get("date_iso", ""))
+    return "ok", {"hash": h, "width": dims[0], "height": dims[1]}
+
+
+def process_batch(rows: list[dict], out_dir: Path, out_f, dead_f, counters: dict,
+                   base_delay: float = 1.0) -> list[dict]:
+    """Process rows sequentially with per-request delay. Retries 429s inline."""
+    skipped = []
+    consecutive_429 = 0
+
+    for row in rows:
+        time.sleep(base_delay)
+
+        status, result = None, None
+        for attempt in range(3):
+            status, result = fetch_one(row, out_dir)
+            if status != "rate_limited":
+                break
+            wait = 5 + attempt * 5
+            print(f"    429 on attempt {attempt+1}, waiting {wait}s...", flush=True)
+            time.sleep(wait)
+
+        if status == "rate_limited":
+            consecutive_429 += 1
+            if consecutive_429 >= 5:
+                print(f"    {consecutive_429} consecutive 429s, cooling down 60s...", flush=True)
+                time.sleep(60)
+                consecutive_429 = 0
+        else:
+            consecutive_429 = 0
+
+        if status == "ok":
+            counters["ok"] += 1
+            out_f.write(json.dumps(result) + "\n")
+            out_f.flush()
+        elif status == "rate_limited":
+            counters["rate_limited"] += 1
+            skipped.append(row)
+        elif status == "small":
+            counters["small"] += 1
+            dead_f.write(row["hash"] + "\n")
+            dead_f.flush()
+        else:
+            counters["dead"] += 1
+            dead_f.write(row["hash"] + "\n")
+            dead_f.flush()
+
+    return skipped
+
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description="Fetch Flickr originals for YFCC manifest")
+    parser.add_argument("--manifest", type=Path, default=Path("manifest.tsv"),
+                        help="Path to manifest TSV (default: manifest.tsv)")
+    parser.add_argument("--out-dir", type=Path, default=Path("photos"),
+                        help="Directory for downloaded JPEGs (default: photos/)")
+    parser.add_argument("--results-file", type=Path, default=Path("flickr_originals.jsonl"),
+                        help="JSONL tracking successful downloads (default: flickr_originals.jsonl)")
+    parser.add_argument("--dead-file", type=Path, default=Path("flickr_dead.txt"),
+                        help="File tracking dead/small hashes (default: flickr_dead.txt)")
+    parser.add_argument("--tiers", default="medium,large",
+                        help="Comma-separated resolution tiers to fetch (default: medium,large)")
+    parser.add_argument("--fast-delay", type=float, default=0.3,
+                        help="Delay for known-alive users (default: 0.3)")
+    parser.add_argument("--probe-delay", type=float, default=1.0,
+                        help="Delay for probing unsampled users (default: 1.0)")
+    args = parser.parse_args()
+
+    tiers = set(args.tiers.split(","))
+    out_dir = args.out_dir
+    results_file = args.results_file
+    dead_file = args.dead_file
+
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    # Load manifest rows for requested tiers
+    all_rows = []
+    with open(args.manifest) as f:
+        for row in csv.DictReader(f, delimiter="\t"):
+            if row["resolution_tier"] in tiers:
+                all_rows.append(row)
+
+    # Resume: skip already-fetched and known-dead
+    done_hashes = set()
+    if results_file.is_file():
+        for line in results_file.read_text().splitlines():
+            done_hashes.add(json.loads(line)["hash"])
+    dead_hashes = set()
+    if dead_file.is_file():
+        dead_hashes = set(dead_file.read_text().splitlines())
+
+    skip = done_hashes | dead_hashes
+
+    # Group remaining photos by user
+    user_rows = defaultdict(list)
+    for r in all_rows:
+        if r["hash"] not in skip:
+            user_rows[r["uid"]].append(r)
+
+    # Classify users from prior data
+    all_by_uid = defaultdict(list)
+    for r in all_rows:
+        all_by_uid[r["uid"]].append(r["hash"])
+
+    alive_uids = set()
+    dead_uids = set()
+    unsampled_uids = set()
+    for uid in user_rows:
+        if any(h in done_hashes for h in all_by_uid[uid]):
+            alive_uids.add(uid)
+        elif any(h in dead_hashes for h in all_by_uid[uid]):
+            dead_uids.add(uid)
+        else:
+            unsampled_uids.add(uid)
+
+    n_remaining = sum(len(v) for v in user_rows.values())
+    print(f"Tiers: {args.tiers} | {len(all_rows)} total, {len(done_hashes)} kept, "
+          f"{len(dead_hashes)} known dead, {n_remaining} to probe")
+    print(f"  Users: {len(alive_uids)} alive, {len(unsampled_uids)} unsampled, {len(dead_uids)} dead")
+    print(f"  Delays: {args.fast_delay}s fast, {args.probe_delay}s probe")
+
+    counters = {"ok": len(done_hashes), "dead": 0, "small": 0, "rate_limited": 0}
+
+    with open(results_file, "a") as out_f, open(dead_file, "a") as dead_f:
+
+        def fetch_user(uid, rows, delay):
+            return process_batch(rows, out_dir, out_f, dead_f, counters, base_delay=delay)
+
+        all_rate_limited = []
+        probed = 0
+
+        # Phase 1: known-alive users (fast)
+        for uid in sorted(alive_uids):
+            rows = user_rows.pop(uid, [])
+            if not rows:
+                continue
+            rl = fetch_user(uid, rows, args.fast_delay)
+            all_rate_limited.extend(rl)
+            probed += len(rows)
+
+        if probed:
+            print(f"  alive-users done ({probed} photos): {counters['ok']:,} kept, "
+                  f"{counters['dead']:,} dead, {counters['small']:,} small", flush=True)
+
+        # Phase 2: unsampled users -- probe 1, if alive fast-fetch rest
+        unsampled_list = sorted(unsampled_uids)
+        for i, uid in enumerate(unsampled_list):
+            rows = user_rows.pop(uid, [])
+            if not rows:
+                continue
+
+            rest = rows[1:]
+            ok_before = counters["ok"]
+            rl = fetch_user(uid, [rows[0]], args.probe_delay)
+            all_rate_limited.extend(rl)
+            probed += 1
+
+            if counters["ok"] > ok_before:
+                if rest:
+                    rl = fetch_user(uid, rest, args.fast_delay)
+                    all_rate_limited.extend(rl)
+                    probed += len(rest)
+            elif rest:
+                all_rate_limited.extend(rest)
+
+            if (i + 1) % 200 == 0:
+                print(f"  unsampled {i+1:,}/{len(unsampled_list):,} users: {counters['ok']:,} kept, "
+                      f"{counters['dead']:,} dead, {counters['small']:,} small, "
+                      f"{counters['rate_limited']:,} rate-limited", flush=True)
+
+        print(f"  unsampled done: {counters['ok']:,} kept, {counters['dead']:,} dead, "
+              f"{counters['small']:,} small", flush=True)
+
+        # Phase 3: known-dead users
+        for uid in sorted(dead_uids):
+            rows = user_rows.pop(uid, [])
+            if not rows:
+                continue
+            rl = fetch_user(uid, rows, args.probe_delay)
+            all_rate_limited.extend(rl)
+            probed += len(rows)
+
+        print(f"  dead-users done: {counters['ok']:,} kept, {counters['dead']:,} dead", flush=True)
+
+        # Phase 4: deferred/rate-limited
+        if all_rate_limited:
+            print(f"  Deferred/rate-limited: {len(all_rate_limited)} remaining at {args.probe_delay}s", flush=True)
+            still_rl = process_batch(all_rate_limited, out_dir, out_f, dead_f, counters)
+            if still_rl:
+                print(f"  {len(still_rl)} still rate-limited after final pass", flush=True)
+
+    n_files = sum(1 for f in out_dir.iterdir() if f.suffix == ".jpg" and f.stat().st_size > 0)
+    print(f"\nDone. {counters['ok']:,} hi-res, {counters['dead']:,} dead, "
+          f"{counters['small']:,} small, {counters['rate_limited']:,} still rate-limited")
+    print(f"{n_files:,} total files on disk")
+
+
+if __name__ == "__main__":
+    main()

scripts/upload_hf.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""Create and upload tar shards to HuggingFace, one at a time to save disk."""
+
+import argparse
+import os
+import tarfile
+from pathlib import Path
+
+from huggingface_hub import HfApi
+
+SHARD_SIZE = 1_000_000_000  # ~1GB per shard
+
+
+def get_existing_shards(api: HfApi, repo_id: str, prefix: str) -> set:
+    """Check which shards already exist on HF."""
+    try:
+        files = api.list_repo_files(repo_id, repo_type="dataset")
+        return {f for f in files if f.startswith(f"{prefix}/") and f.endswith(".tar")}
+    except Exception:
+        return set()
+
+
+def upload_folder_as_shards(api: HfApi, repo_id: str, src_dir: Path, prefix: str, tmp_dir: Path):
+    """Create tar shards from src_dir, upload each, delete after upload."""
+    existing = get_existing_shards(api, repo_id, prefix)
+    if existing:
+        print(f"  Found {len(existing)} existing shards, will skip them", flush=True)
+
+    files = sorted(f for f in src_dir.iterdir() if f.is_file())
+    shard_idx = 0
+    current_size = 0
+    shard_files = []
+
+    for f in files:
+        shard_files.append(f)
+        current_size += f.stat().st_size
+
+        if current_size >= SHARD_SIZE:
+            _make_and_upload(api, repo_id, shard_files, prefix, shard_idx, existing, tmp_dir)
+            shard_idx += 1
+            shard_files = []
+            current_size = 0
+
+    if shard_files:
+        _make_and_upload(api, repo_id, shard_files, prefix, shard_idx, existing, tmp_dir)
+
+
+def _make_and_upload(api: HfApi, repo_id: str, files: list, prefix: str, idx: int,
+                     existing: set, tmp_dir: Path):
+    name = f"{prefix}-{idx:04d}.tar"
+    repo_path = f"{prefix}/{name}"
+    if repo_path in existing:
+        print(f"  Skipping {name} (already uploaded)", flush=True)
+        return
+    tar_path = tmp_dir / name
+    print(f"  Creating {name} ({len(files)} files)...", flush=True)
+
+    with tarfile.open(tar_path, "w") as tar:
+        for f in files:
+            tar.add(f, arcname=f.name)
+
+    size_mb = tar_path.stat().st_size / 1_000_000
+    print(f"  Uploading {name} ({size_mb:.0f} MB)...", flush=True)
+
+    api.upload_file(
+        path_or_fileobj=str(tar_path),
+        path_in_repo=repo_path,
+        repo_id=repo_id,
+        repo_type="dataset",
+    )
+
+    tar_path.unlink()
+    print(f"  Done {name}", flush=True)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Upload photo shards to HuggingFace")
+    parser.add_argument("--src-dir", type=Path, required=True,
+                        help="Directory containing photos to upload")
+    parser.add_argument("--prefix", default="yfcc",
+                        help="Prefix for shard names in repo (default: yfcc)")
+    parser.add_argument("--repo", default="lightcella/photo-corpus",
+                        help="HuggingFace dataset repo ID")
+    parser.add_argument("--tmp-dir", type=Path, default=Path("."),
+                        help="Directory for temporary tar files (default: current dir)")
+    parser.add_argument("--shard-size", type=int, default=SHARD_SIZE,
+                        help="Target shard size in bytes (default: 1GB)")
+    args = parser.parse_args()
+
+    global SHARD_SIZE
+    SHARD_SIZE = args.shard_size
+
+    api = HfApi()
+    args.tmp_dir.mkdir(parents=True, exist_ok=True)
+
+    n_files = sum(1 for f in args.src_dir.iterdir() if f.is_file())
+    print(f"Uploading {n_files} files from {args.src_dir} as '{args.prefix}' shards...")
+    upload_folder_as_shards(api, args.repo, args.src_dir, args.prefix, args.tmp_dir)
+    print("All done!")
+
+
+if __name__ == "__main__":
+    main()