| |
| """ |
| 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) |
|
|
| |
| 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) |
|
|
| |
| 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 |
|
|
| |
| user_rows = defaultdict(list) |
| for r in all_rows: |
| if r["hash"] not in skip: |
| user_rows[r["uid"]].append(r) |
|
|
| |
| 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 |
|
|
| |
| 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) |
|
|
| |
| 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) |
|
|
| |
| 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) |
|
|
| |
| 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() |
|
|
