Rescue local-only reddit data: batch 3 (23 files)

.gitattributes

@@ -7061,3 +7061,8 @@ reddit/_rescue_20260917/nonimage/whereisthis/posts_with_comments.jsonl filter=lf
 reddit/_rescue_20260917/raw/r_GeoPuzzle_comments.jsonl filter=lfs diff=lfs merge=lfs -text
 reddit/_rescue_20260917/raw/r_GeoPuzzle_posts.jsonl filter=lfs diff=lfs merge=lfs -text
 reddit/_rescue_20260917/raw/r_PictureGame_comments.jsonl filter=lfs diff=lfs merge=lfs -text
+reddit/_rescue_20260917/raw/r_PictureGame_posts.jsonl filter=lfs diff=lfs merge=lfs -text
+reddit/_rescue_20260917/raw/r_whereisthis_comments.jsonl filter=lfs diff=lfs merge=lfs -text
+reddit/_rescue_20260917/raw/r_whereisthis_posts.jsonl filter=lfs diff=lfs merge=lfs -text
+reddit/_rescue_20260917/raw/solved_whereisthis/solved_comments.jsonl filter=lfs diff=lfs merge=lfs -text
+reddit/_rescue_20260917/raw/solved_whereisthis/solved_posts_with_comments.jsonl filter=lfs diff=lfs merge=lfs -text

reddit/_rescue_20260917/raw/r_PictureGame_posts.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:35cf14778d210953e13c5b6f1011063aad8551de0a48d30bceb79d04d45e8ede
+size 507715312

reddit/_rescue_20260917/raw/r_whereisthis_comments.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d8da1e85b27237debbd6475e28426fef7fd0c3289a50d71222a94ab234d05334
+size 360490554

reddit/_rescue_20260917/raw/r_whereisthis_posts.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:34e3fe20184410bd93a59d4ea834392938b4b7ffdb803b45c7c23bbdec3d9f36
+size 151490892

reddit/_rescue_20260917/raw/scripts/rebase_canonical_paths.py

@@ -0,0 +1,82 @@
+"""Move derived canonical paths into a separate directory namespace."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+from pathlib import Path
+
+
+PATH_RE = re.compile(r"^reddit/images/(whereisthis|GeoPuzzle|PictureGame)/(\d{4})/(.+)$")
+
+
+def rebase(path: str | None) -> str | None:
+    if not path:
+        return path
+    match = PATH_RE.match(path)
+    if not match:
+        return path
+    return f"reddit/images/{match.group(1)}/canonical/{match.group(2)}/{match.group(3)}"
+
+
+def jsonl(path: Path):
+    with path.open("r", encoding="utf-8") as handle:
+        for line in handle:
+            if line.strip():
+                yield json.loads(line)
+
+
+def transform(value):
+    if isinstance(value, dict):
+        result = {key: transform(item) for key, item in value.items()}
+        for key in ("canonical_path", "remote_path"):
+            if key in result and isinstance(result[key], str):
+                result[key] = rebase(result[key])
+        return result
+    if isinstance(value, list):
+        return [transform(item) for item in value]
+    if isinstance(value, str):
+        return PATH_RE.sub(lambda m: f"reddit/images/{m.group(1)}/canonical/{m.group(2)}/{m.group(3)}", value)
+    return value
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--source-map", type=Path, required=True)
+    parser.add_argument("--source-bundle", type=Path, required=True)
+    parser.add_argument("--output-map", type=Path, required=True)
+    parser.add_argument("--output-bundle", type=Path, required=True)
+    args = parser.parse_args()
+
+    args.output_map.parent.mkdir(parents=True, exist_ok=True)
+    with args.output_map.open("w", encoding="utf-8", newline="\n") as out:
+        for row in jsonl(args.source_map):
+            out.write(json.dumps(transform(row), ensure_ascii=False, separators=(",", ":")) + "\n")
+
+    source = args.source_bundle / "reddit"
+    output = args.output_bundle / "reddit"
+    in_place = source.resolve() == output.resolve()
+    for path in source.rglob("*.jsonl"):
+        destination = path if in_place else output / path.relative_to(source)
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        temp = destination.with_suffix(destination.suffix + ".part")
+        with path.open("r", encoding="utf-8") as src, temp.open("w", encoding="utf-8", newline="\n") as dst:
+            for line in src:
+                if line.strip():
+                    dst.write(json.dumps(transform(json.loads(line)), ensure_ascii=False, separators=(",", ":")) + "\n")
+                else:
+                    dst.write(line)
+        temp.replace(destination)
+    for path in source.rglob("*.json"):
+        destination = path if in_place else output / path.relative_to(source)
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        if path.name not in {"canonical_migration_report.json", "canonical_validation_report.json"}:
+            destination.write_bytes(path.read_bytes())
+
+    print(json.dumps({"status": "passed", "source_map": str(args.source_map), "output_map": str(args.output_map), "output_bundle": str(args.output_bundle)}, ensure_ascii=False), flush=True)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

reddit/_rescue_20260917/raw/scripts/rebuild_canonical_names_from_associations.py

@@ -0,0 +1,122 @@
+"""Rebuild canonical image names from the fully recovered associations."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import time
+from collections import Counter, defaultdict
+from pathlib import Path
+
+
+def jsonl(path: Path):
+    with path.open("r", encoding="utf-8") as handle:
+        for number, line in enumerate(handle, 1):
+            if line.strip():
+                try:
+                    yield json.loads(line)
+                except json.JSONDecodeError as exc:
+                    raise ValueError(f"invalid JSON: {path}:{number}") from exc
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--inventory", type=Path, required=True)
+    parser.add_argument("--associations", type=Path, required=True)
+    parser.add_argument("--old-naming-map", type=Path, required=True)
+    parser.add_argument("--output-root", type=Path, required=True)
+    parser.add_argument("--namespace", default="")
+    args = parser.parse_args()
+    started = time.time()
+    args.output_root.mkdir(parents=True, exist_ok=True)
+
+    inventory = {(x["community"], x["filename"]): x for x in jsonl(args.inventory)}
+    associations = {(x["community"], x["filename"]): x for x in jsonl(args.associations)}
+    old_names = {(x["community"], x["old_filename"]): x for x in jsonl(args.old_naming_map)}
+    if len(inventory) != 225307 or set(inventory) != set(associations) or set(inventory) != set(old_names):
+        raise RuntimeError("inventory, association, and old naming keys do not match")
+
+    grouped = defaultdict(list)
+    missing_post_id = []
+    for key, inv in inventory.items():
+        assoc = associations[key]
+        refs = assoc.get("references", [])
+        direct = sorted({
+            str(x.get("post_id") or "").strip() for x in refs
+            if x.get("owner_type") == "post"
+            and str(x.get("owner_id") or "").strip() == str(x.get("post_id") or "").strip()
+            and str(x.get("post_id") or "").strip()
+        })
+        post_ids = sorted({str(x).strip() for x in assoc.get("post_ids", []) if str(x).strip()})
+        if not (direct or post_ids):
+            missing_post_id.append({"community": key[0], "filename": key[1]})
+            continue
+        post_id = (direct or post_ids)[0]
+        grouped[(key[0], post_id)].append((key, inv, assoc, old_names[key]))
+    if missing_post_id:
+        (args.output_root / "missing_post_ids.json").write_text(json.dumps(missing_post_id, ensure_ascii=False, indent=2), encoding="utf-8")
+        raise RuntimeError(f"images without post id: {len(missing_post_id)}")
+
+    mappings = []
+    name_counts = Counter()
+    changed_paths = 0
+    for (community, post_id), items in sorted(grouped.items()):
+        items.sort(key=lambda x: x[0][1])
+        width = max(3, len(str(len(items))))
+        for sequence, (key, inv, assoc, old) in enumerate(items, 1):
+            extension = Path(key[1]).suffix.lower()
+            sha = old["sha256"]
+            new_filename = f"{community}_{post_id}_{sequence:0{width}d}_{sha[:8]}{extension}"
+            shard = int(inv.get("shard", 0))
+            namespace = f"{args.namespace.strip('/')}/" if args.namespace.strip("/") else ""
+            new_path = f"reddit/images/{community}/{namespace}{shard:04d}/{new_filename}"
+            name_counts[(community, new_filename)] += 1
+            changed_paths += new_path != old["new_remote_path"]
+            mappings.append({
+                "community": community,
+                "old_filename": key[1],
+                "old_remote_path": inv["relative_path"],
+                "legacy_remote_path": inv["legacy_relative_path"],
+                "local_path": old["local_path"],
+                "size": int(inv["size"]),
+                "sha256": sha,
+                "canonical_post_id": post_id,
+                "sequence": sequence,
+                "association_count": int(assoc["association_count"]),
+                "associations": assoc.get("references", []),
+                "new_filename": new_filename,
+                "new_remote_path": new_path,
+            })
+
+    collisions = [
+        {"community": key[0], "new_filename": key[1], "count": count}
+        for key, count in name_counts.items() if count > 1
+    ]
+    if collisions:
+        (args.output_root / "canonical_name_collisions.json").write_text(json.dumps(collisions, ensure_ascii=False, indent=2), encoding="utf-8")
+        raise RuntimeError(f"canonical name collisions: {len(collisions)}")
+    output = args.output_root / "canonical_image_mapping.jsonl"
+    with output.open("w", encoding="utf-8", newline="\n") as handle:
+        for row in sorted(mappings, key=lambda x: (x["community"], x["old_filename"])):
+            handle.write(json.dumps(row, ensure_ascii=False, separators=(",", ":")) + "\n")
+    report = {
+        "status": "passed",
+        "created_at": time.time(),
+        "elapsed_seconds": round(time.time() - started, 2),
+        "inventory_records": len(inventory),
+        "mapping_records": len(mappings),
+        "images_without_post_id": 0,
+        "canonical_name_collisions": 0,
+        "paths_changed_from_old_audit": changed_paths,
+        "contains_unlinked_name": any("_unlinked_" in x["new_filename"] for x in mappings),
+        "namespace": args.namespace.strip("/"),
+        "source_images_modified": False,
+        "remote_modified": False,
+    }
+    (args.output_root / "canonical_mapping_summary.json").write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding="utf-8")
+    print(json.dumps(report, ensure_ascii=False), flush=True)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

reddit/_rescue_20260917/raw/scripts/recover_reddit_image_associations.py

@@ -0,0 +1,163 @@
+"""Recover image-to-post/comment associations from raw Reddit records.
+
+Read-only: no source image, post JSONL, bundle, or remote repository is changed.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import time
+from collections import Counter, defaultdict
+from pathlib import Path
+
+
+COMMUNITIES = ("whereisthis", "GeoPuzzle", "PictureGame")
+
+
+def jsonl(path: Path):
+    if not path.exists():
+        return
+    with path.open("r", encoding="utf-8") as handle:
+        for number, line in enumerate(handle, 1):
+            if line.strip():
+                try:
+                    yield json.loads(line)
+                except json.JSONDecodeError as exc:
+                    raise ValueError(f"Invalid JSON: {path}:{number}") from exc
+
+
+def filename_from_local(value) -> str | None:
+    if not isinstance(value, str) or not value:
+        return None
+    return Path(value.replace("\\", "/")).name
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--inventory", type=Path, required=True)
+    parser.add_argument("--raw-root", type=Path, required=True)
+    parser.add_argument("--overflow-root", type=Path)
+    parser.add_argument("--bundle-root", type=Path)
+    parser.add_argument("--output-root", type=Path, required=True)
+    args = parser.parse_args()
+    started = time.time()
+    args.output_root.mkdir(parents=True, exist_ok=True)
+
+    inventory = list(jsonl(args.inventory) or ())
+    inventory_keys = {(r["community"], r["filename"]): r for r in inventory}
+    refs: dict[tuple[str, str], dict[tuple, dict]] = defaultdict(dict)
+    source_counts = Counter()
+    raw_rows = 0
+    raw_missing_local = 0
+    raw_not_inventory = 0
+
+    def add_record(community: str, record: dict, source: str) -> None:
+        nonlocal raw_rows, raw_missing_local, raw_not_inventory
+        raw_rows += 1
+        filename = filename_from_local(record.get("local_path"))
+        if not filename:
+            raw_missing_local += 1
+            return
+        key = (community, filename)
+        if key not in inventory_keys:
+            raw_not_inventory += 1
+            return
+        association = {
+            "post_id": str(record.get("post_id") or "").strip(),
+            "owner_type": str(record.get("owner_type") or "").strip(),
+            "owner_id": str(record.get("owner_id") or "").strip(),
+            "url": record.get("url"),
+            "status": record.get("status"),
+            "bytes": record.get("bytes"),
+            "source": source,
+        }
+        key2 = tuple(association.get(k) for k in ("post_id", "owner_type", "owner_id", "url"))
+        existing = refs[key].get(key2)
+        if existing:
+            sources = set(existing.get("sources", []))
+            sources.add(source)
+            existing["sources"] = sorted(sources)
+        else:
+            association["sources"] = [source]
+            refs[key][key2] = association
+        source_counts[source] += 1
+
+    raw_roots = [args.raw_root]
+    if args.overflow_root:
+        raw_roots.append(args.overflow_root)
+    for community in COMMUNITIES:
+      for raw_root in raw_roots:
+        community_root = raw_root / community
+        for path in sorted(community_root.glob("retry_state.jsonl")):
+            for record in jsonl(path) or ():
+                add_record(community, record, f"{raw_root.name}/retry_state.jsonl")
+        for path in sorted(community_root.glob("image_manifest*.jsonl")):
+            source = f"{raw_root.name}/{path.name}"
+            for record in jsonl(path) or ():
+                add_record(community, record, source)
+
+    if args.bundle_root:
+        bundle_manifest_root = args.bundle_root / "image_manifests"
+        for path in sorted(bundle_manifest_root.rglob("*.jsonl")):
+            community = path.parent.name
+            if community not in COMMUNITIES:
+                continue
+            for record in jsonl(path) or ():
+                add_record(community, record, f"bundle/{community}/{path.name}")
+
+    recovered = []
+    unresolved = []
+    ambiguous = []
+    for record in inventory:
+        key = (record["community"], record["filename"])
+        associations = sorted(
+            refs.get(key, {}).values(),
+            key=lambda x: (x["post_id"], x["owner_type"], x["owner_id"], x["url"] or "", x["source"]),
+        )
+        post_ids = sorted({x["post_id"] for x in associations if x["post_id"]})
+        output = {
+            "community": record["community"],
+            "filename": record["filename"],
+            "relative_path": record["relative_path"],
+            "legacy_relative_path": record["legacy_relative_path"],
+            "sha256": record.get("sha256"),
+            "size": record["size"],
+            "post_ids": post_ids,
+            "references": associations,
+            "association_count": len(associations),
+            "association_status": "recovered" if associations else "unresolved",
+        }
+        recovered.append(output)
+        if not associations:
+            unresolved.append(output)
+        if len(post_ids) > 1:
+            ambiguous.append(output)
+
+    association_path = args.output_root / "association_recovery.jsonl"
+    with association_path.open("w", encoding="utf-8") as handle:
+        for record in recovered:
+            handle.write(json.dumps(record, ensure_ascii=False, separators=(",", ":")) + "\n")
+    for name, records in (("association_unresolved.json", unresolved), ("association_ambiguous.json", ambiguous)):
+        (args.output_root / name).write_text(json.dumps(records, ensure_ascii=False, indent=2), encoding="utf-8")
+    summary = {
+        "created_at": time.time(),
+        "elapsed_seconds": round(time.time() - started, 3),
+        "inventory_records": len(inventory),
+        "recovered_records": len(recovered) - len(unresolved),
+        "unresolved_records": len(unresolved),
+        "ambiguous_records": len(ambiguous),
+        "raw_rows_scanned": raw_rows,
+        "raw_rows_missing_local_path": raw_missing_local,
+        "raw_rows_not_in_inventory": raw_not_inventory,
+        "source_counts": dict(source_counts),
+        "original_images_modified": False,
+        "remote_modified": False,
+    }
+    (args.output_root / "association_recovery_summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8")
+    print(json.dumps(summary, ensure_ascii=False), flush=True)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

reddit/_rescue_20260917/raw/scripts/resume_reddit_upload_after_rate_limit.ps1

@@ -0,0 +1,51 @@
+param(
+    [int]$PollSeconds = 300
+)
+
+$ErrorActionPreference = 'Stop'
+$python = 'C:\Users\zong zilu\AppData\Local\Programs\Python\Python313\python.exe'
+$script = 'D:\GeoAgent\Geo-CoT dataset\外网图像地理定位数据收集\reddit_posts\upload_reddit_images_batched.py'
+$watcher = 'D:\GeoAgent\Geo-CoT dataset\外网图像地理定位数据收集\reddit_posts\finalize_reddit_upload_manifest.ps1'
+$log = 'C:\GeoAgent_hf_upload_cache\reddit\delayed_resume.log'
+
+function Write-Log([string]$message) {
+    Add-Content -LiteralPath $log -Value "$(Get-Date -Format o) $message" -Encoding UTF8
+}
+
+Write-Log "poll_start seconds=$PollSeconds"
+while ($true) {
+    $probeArgs = @(
+        $script, 'upload', '--batch-size', '10000', '--max-batch-bytes', '5368709120',
+        '--upload-threads', '8', '--request-timeout', '60', '--batch-retries', '1',
+        '--plan-only'
+    )
+    $probe = Start-Process -FilePath $python -ArgumentList $probeArgs -Wait -PassThru -WindowStyle Hidden
+    Write-Log "rate_limit_probe exit_code=$($probe.ExitCode)"
+    if ($probe.ExitCode -eq 0) { break }
+    Start-Sleep -Seconds $PollSeconds
+}
+Write-Log 'rate_limit_probe_ready starting_uploader'
+
+$uploadArgs = @(
+    $script, 'upload', '--batch-size', '10000', '--max-batch-bytes', '5368709120',
+    '--upload-threads', '8', '--request-timeout', '180', '--batch-retries', '3',
+    '--rate-limit-backoff-seconds', '3700', '--rate-limit-poll-seconds', "$PollSeconds", '--heartbeat-seconds', '30'
+)
+$uploadInfo = [System.Diagnostics.ProcessStartInfo]::new()
+$uploadInfo.FileName = $python
+$uploadInfo.UseShellExecute = $true
+$uploadInfo.CreateNoWindow = $true
+$uploadInfo.WindowStyle = [System.Diagnostics.ProcessWindowStyle]::Hidden
+foreach ($value in $uploadArgs) { $uploadInfo.ArgumentList.Add($value) }
+$uploadProcess = [System.Diagnostics.Process]::Start($uploadInfo)
+Write-Log "uploader_started pid=$($uploadProcess.Id)"
+
+$watchArgs = @('-NoLogo', '-NoProfile', '-NonInteractive', '-File', $watcher, '-UploadProcessId', "$($uploadProcess.Id)")
+$watchInfo = [System.Diagnostics.ProcessStartInfo]::new()
+$watchInfo.FileName = (Get-Command pwsh.exe).Source
+$watchInfo.UseShellExecute = $true
+$watchInfo.CreateNoWindow = $true
+$watchInfo.WindowStyle = [System.Diagnostics.ProcessWindowStyle]::Hidden
+foreach ($value in $watchArgs) { $watchInfo.ArgumentList.Add($value) }
+$watchProcess = [System.Diagnostics.Process]::Start($watchInfo)
+Write-Log "watcher_started pid=$($watchProcess.Id)"

reddit/_rescue_20260917/raw/scripts/retry_circuit_skipped.py

@@ -0,0 +1,113 @@
+"""Retry only URLs skipped by the previous domain circuit breaker."""
+
+import argparse
+from collections import defaultdict
+import json
+import logging
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from urllib.parse import urlparse
+
+import retry_failed_images as downloader
+
+
+def latest_records(path):
+    records = {}
+    for record in downloader.read_manifest(path):
+        records[record["url"]] = record
+    return records
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--community", default="PictureGame")
+    parser.add_argument("--workers", type=int, default=6)
+    parser.add_argument("--per-domain-workers", type=int, default=2)
+    parser.add_argument("--attempts", type=int, default=2)
+    parser.add_argument("--connect-timeout", type=int, default=10)
+    parser.add_argument("--max-time", type=int, default=30)
+    parser.add_argument("--min-free-gb", type=float, default=5.0)
+    parser.add_argument("--limit", type=int)
+    parser.add_argument("--restart", action="store_true")
+    parser.add_argument("--source", type=Path, default=Path(r"C:\GeoAgent_reddit_overflow\retry_state\PictureGame\extended_retry_state.jsonl"))
+    parser.add_argument("--overflow-root", type=Path, default=downloader.DEFAULT_OVERFLOW_ROOT)
+    parser.add_argument("--state-root", type=Path, default=downloader.DEFAULT_STATE_ROOT)
+    args = parser.parse_args()
+
+    if min(args.workers, args.per_domain_workers, args.attempts, args.connect_timeout, args.max_time) <= 0:
+        raise ValueError("workers, attempts and timeouts must be positive")
+
+    community_dir = downloader.OUT_ROOT / args.community
+    primary_dir = community_dir / "images"
+    overflow_dir = args.overflow_root / args.community / "images"
+    state_dir = args.state_root / args.community
+    state_dir.mkdir(parents=True, exist_ok=True)
+    checkpoint_path = state_dir / "circuit_retry_state.jsonl"
+    log_path = state_dir / "circuit_retry.log"
+    output_path = state_dir / "image_manifest_circuit_retry.jsonl"
+    logging.basicConfig(filename=log_path, level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s", force=True)
+
+    candidates = [r for r in latest_records(args.source).values() if r.get("error") == "domain_circuit_open"]
+    candidates.sort(key=lambda r: (urlparse(r["url"]).netloc.lower(), r["url"]))
+    if args.limit is not None:
+        candidates = candidates[:args.limit]
+
+    checkpoint = {}
+    if checkpoint_path.exists() and not args.restart:
+        checkpoint = latest_records(checkpoint_path)
+    pending = [r for r in candidates if r["url"] not in checkpoint]
+    existing = downloader.build_existing_index([primary_dir, overflow_dir])
+    minimum = int(args.min_free_gb * 1024 ** 3)
+
+    downloader.ATTEMPTS = args.attempts
+    downloader.CONNECT_TIMEOUT = args.connect_timeout
+    downloader.MAX_TIME = args.max_time
+    downloader.domain_is_open = lambda _url: False
+    downloader.update_domain_health = lambda _url, _succeeded: None
+
+    index_lock = threading.Lock()
+    domain_locks = defaultdict(lambda: threading.BoundedSemaphore(args.per_domain_workers))
+
+    def retry(record):
+        with index_lock:
+            known = existing.get(downloader.image_stem(record["url"]))
+        if known:
+            return {**record, "status": "ok", "local_path": str(known), "bytes": known.stat().st_size,
+                    "error": None, "retry_attempts": 0, "reused": True}
+        domain = urlparse(record["url"]).netloc.lower()
+        with domain_locks[domain]:
+            return downloader.retry_one(record, primary_dir, overflow_dir, minimum, existing, True)
+
+    logging.info("prepared candidates=%s checkpoint=%s pending=%s", len(candidates), len(checkpoint), len(pending))
+    print(json.dumps({"candidates": len(candidates), "checkpoint": len(checkpoint), "pending": len(pending)}, ensure_ascii=False), flush=True)
+    mode = "w" if args.restart else "a"
+    started = time.time()
+    ok = sum(r.get("status") == "ok" for r in checkpoint.values())
+    failed = sum(r.get("status") == "failed" for r in checkpoint.values())
+    with checkpoint_path.open(mode, encoding="utf-8") as handle, ThreadPoolExecutor(max_workers=args.workers) as pool:
+        futures = [pool.submit(retry, record) for record in pending]
+        for index, future in enumerate(as_completed(futures), 1):
+            result = future.result()
+            if result.get("status") == "internal_error":
+                raise RuntimeError(f"internal downloader error: {result.get('error')}")
+            checkpoint[result["url"]] = result
+            handle.write(json.dumps(result, ensure_ascii=False, separators=(",", ":")) + "\n")
+            handle.flush()
+            ok += result.get("status") == "ok"
+            failed += result.get("status") == "failed"
+            if index % 25 == 0 or index == len(pending):
+                completed = len(checkpoint)
+                speed = index / max(time.time() - started, 0.001)
+                logging.info("progress=%s/%s ok=%s failed=%s speed=%.2f records/s", completed, len(candidates), ok, failed, speed)
+                print(json.dumps({"progress": completed, "total": len(candidates), "ok": ok, "failed": failed, "speed": round(speed, 3)}), flush=True)
+
+    downloader.write_jsonl(output_path, checkpoint.values())
+    final = {"status": "complete", "candidates": len(candidates), "ok": ok, "failed": failed, "output": str(output_path)}
+    logging.info("complete %s", json.dumps(final, ensure_ascii=False))
+    print(json.dumps(final, ensure_ascii=False), flush=True)
+
+
+if __name__ == "__main__":
+    main()

reddit/_rescue_20260917/raw/scripts/retry_failed_after_completion.py

@@ -0,0 +1,123 @@
+"""Run an extended retry pass after the primary downloader exits.
+
+This script waits for the primary PID, reads the latest checkpoint on C:, and
+retries only the latest failed record for each URL. Existing images are reused.
+"""
+
+import argparse
+import json
+import logging
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+
+import retry_failed_images as downloader
+
+
+def wait_for_pid(pid, poll_seconds):
+    while True:
+        try:
+            import psutil
+            if not psutil.pid_exists(pid):
+                return
+        except ImportError:
+            try:
+                import subprocess
+                result = subprocess.run(["tasklist", "/FI", f"PID eq {pid}"], capture_output=True, text=True)
+                if str(pid) not in result.stdout:
+                    return
+            except OSError:
+                return
+        time.sleep(poll_seconds)
+
+
+def latest_records(path):
+    latest = {}
+    for record in downloader.read_manifest(path):
+        latest[record["url"]] = record
+    return latest
+
+
+def retry_community(name, args):
+    community_dir = downloader.OUT_ROOT / name
+    primary_dir = community_dir / "images"
+    overflow_dir = args.overflow_root / name / "images"
+    state_dir = args.state_root / name
+    checkpoint = state_dir / "retry_state.jsonl"
+    log_path = state_dir / "extended_retry.log"
+    state_out = state_dir / "extended_retry_state.jsonl"
+    manifest_out = state_dir / "image_manifest_extended_retry.jsonl"
+    logging.basicConfig(filename=log_path, level=logging.INFO,
+                        format="%(asctime)s %(levelname)s %(message)s", force=True)
+
+    latest = latest_records(checkpoint)
+    candidates = [r for r in latest.values() if r.get("status") == "failed"]
+    if not args.retry_all:
+        candidates = [r for r in candidates if downloader.should_retry(r, False)]
+    if args.limit is not None:
+        candidates = candidates[:args.limit]
+
+    existing = downloader.build_existing_index([primary_dir, overflow_dir])
+    minimum = int(args.min_free_gb * 1024 ** 3)
+    logging.info("prepared community=%s candidates=%s existing_images=%s", name, len(candidates), len(existing))
+    print(json.dumps({"community": name, "candidates": len(candidates), "existing_images": len(existing)}, ensure_ascii=False), flush=True)
+
+    ok = failed = internal = 0
+    results = {}
+    with state_out.open("w", encoding="utf-8") as handle:
+        with ThreadPoolExecutor(max_workers=args.workers) as pool:
+            futures = [pool.submit(extended_retry_one, r, primary_dir, overflow_dir, minimum, existing, args) for r in candidates]
+            for index, future in enumerate(as_completed(futures), 1):
+                result = future.result()
+                if result.get("status") == "internal_error":
+                    internal += 1
+                    raise RuntimeError(f"internal error: {result.get('error')}")
+                results[result["url"]] = result
+                handle.write(json.dumps(result, ensure_ascii=False, separators=(",", ":")) + "\n")
+                handle.flush()
+                if result["status"] == "ok":
+                    ok += 1
+                else:
+                    failed += 1
+                if index % args.batch_log == 0 or index == len(candidates):
+                    logging.info("progress=%s/%s ok=%s failed=%s", index, len(candidates), ok, failed)
+                    print(json.dumps({"community": name, "progress": index, "total": len(candidates), "ok": ok, "failed": failed}, ensure_ascii=False), flush=True)
+
+    original = list(downloader.read_manifest(community_dir / "image_manifest.jsonl"))
+    merged = [results.get(r["url"], r) if r.get("status") == "failed" else r for r in original]
+    downloader.write_jsonl(manifest_out, merged)
+    final = {"community": name, "status": "complete", "candidates": len(candidates), "ok": ok, "failed": failed, "internal": internal, "output": str(manifest_out)}
+    logging.info("complete %s", json.dumps(final, ensure_ascii=False))
+    print(json.dumps(final, ensure_ascii=False), flush=True)
+
+
+def extended_retry_one(record, primary_dir, overflow_dir, minimum, existing, args):
+    downloader.ATTEMPTS = args.attempts
+    downloader.CONNECT_TIMEOUT = args.connect_timeout
+    downloader.MAX_TIME = args.max_time
+    return downloader.retry_one(record, primary_dir, overflow_dir, minimum, existing, True)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--wait-pid", type=int, required=True)
+    parser.add_argument("--communities", nargs="+", choices=["whereisthis", "GeoPuzzle", "PictureGame"], default=["PictureGame"])
+    parser.add_argument("--workers", type=int, default=4)
+    parser.add_argument("--attempts", type=int, default=5)
+    parser.add_argument("--connect-timeout", type=int, default=15)
+    parser.add_argument("--max-time", type=int, default=60)
+    parser.add_argument("--min-free-gb", type=float, default=5.0)
+    parser.add_argument("--batch-log", type=int, default=16)
+    parser.add_argument("--limit", type=int)
+    parser.add_argument("--retry-all", action="store_true")
+    parser.add_argument("--overflow-root", type=Path, default=downloader.DEFAULT_OVERFLOW_ROOT)
+    parser.add_argument("--state-root", type=Path, default=downloader.DEFAULT_STATE_ROOT)
+    args = parser.parse_args()
+    print(json.dumps({"waiting_for_pid": args.wait_pid}, ensure_ascii=False), flush=True)
+    wait_for_pid(args.wait_pid, 10)
+    for name in args.communities:
+        retry_community(name, args)
+
+
+if __name__ == "__main__":
+    main()

reddit/_rescue_20260917/raw/scripts/retry_failed_images.py

@@ -0,0 +1,328 @@
+"""Retry failed image URLs from the three-community collection.
+
+The original manifest is never modified. Results are checkpointed per URL and
+the merged manifest is written only after a community finishes.
+"""
+
+import argparse
+import json
+import logging
+import os
+import re
+import shutil
+import subprocess
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from urllib.parse import urlparse
+
+
+ROOT = Path(__file__).resolve().parent
+OUT_ROOT = ROOT / "solved_communities"
+DEFAULT_WORKERS = 12
+BATCH_SIZE = 32
+ATTEMPTS = 2
+CONNECT_TIMEOUT = 5
+MAX_TIME = 15
+DEFAULT_MIN_FREE_GB = 5.0
+DEFAULT_OVERFLOW_ROOT = Path(r"C:\GeoAgent_reddit_overflow\solved_communities")
+DEFAULT_STATE_ROOT = Path(r"C:\GeoAgent_reddit_overflow\retry_state")
+DOMAIN_FAILURE_LIMIT = 8
+URL_RE = re.compile(r"https?://[^\s<>\[\]()\"']+", re.I)
+_storage_notice_lock = threading.Lock()
+_storage_notice_emitted = set()
+_domain_lock = threading.Lock()
+_domain_failures = {}
+
+
+def image_stem(url):
+    import hashlib
+    return hashlib.sha256(url.encode("utf-8")).hexdigest()[:24]
+
+
+def detected_extension(path):
+    try:
+        with path.open("rb") as handle:
+            head = handle.read(512)
+    except OSError:
+        return None
+    if head.startswith(b"\xff\xd8\xff"):
+        return ".jpg"
+    if head.startswith(b"\x89PNG\r\n\x1a\n"):
+        return ".png"
+    if head[:6] in (b"GIF87a", b"GIF89a"):
+        return ".gif"
+    if head.startswith(b"RIFF") and head[8:12] == b"WEBP":
+        return ".webp"
+    if head.startswith(b"BM"):
+        return ".bmp"
+    if head.startswith((b"II*\x00", b"MM\x00*")):
+        return ".tiff"
+    if len(head) >= 12 and head[4:12] in (b"ftypavif", b"ftypavis"):
+        return ".avif"
+    lowered = head.lstrip().lower()
+    if lowered.startswith(b"<svg") or (lowered.startswith(b"<?xml") and b"<svg" in lowered):
+        return ".svg"
+    return None
+
+
+def error_kind(error):
+    text = error or "unknown"
+    if "404" in text:
+        return "http_404"
+    if "403" in text:
+        return "http_403"
+    if "429" in text:
+        return "http_429"
+    if re.search(r"\b4\d\d\b", text):
+        return "http_4xx"
+    if re.search(r"\b5\d\d\b", text):
+        return "http_5xx"
+    if "timed out" in text.lower() or "timeout" in text.lower():
+        return "timeout"
+    if "Empty reply" in text:
+        return "empty_reply"
+    if "SSL" in text or "TLS" in text or "handshake" in text:
+        return "tls_ssl"
+    if "Malformed" in text:
+        return "malformed_url"
+    return "other"
+
+
+def should_retry(record, retry_all):
+    if retry_all:
+        return True
+    return error_kind(record.get("error")) not in {"http_404", "http_403", "http_4xx", "malformed_url"}
+
+
+def request_urls(url):
+    """Prefer HTTPS for legacy HTTP links, then retain the original URL as fallback."""
+    if url.lower().startswith("http://"):
+        https_url = "https://" + url[7:]
+        return [https_url, url]
+    return [url]
+
+
+def attempts_for_error(record):
+    kind = error_kind(record.get("error"))
+    if kind in {"http_404", "http_403", "http_4xx", "malformed_url"}:
+        return 1
+    return ATTEMPTS
+
+
+def build_existing_index(image_dirs):
+    index = {}
+    for image_dir in image_dirs:
+        if not image_dir.exists():
+            continue
+        for path in image_dir.iterdir():
+            if path.is_file() and not path.name.endswith(".part") and path.stat().st_size > 0:
+                index.setdefault(path.stem, path)
+    return index
+
+
+def domain_is_open(url):
+    domain = urlparse(url).netloc.lower()
+    with _domain_lock:
+        return _domain_failures.get(domain, 0) >= DOMAIN_FAILURE_LIMIT
+
+
+def update_domain_health(url, succeeded):
+    domain = urlparse(url).netloc.lower()
+    with _domain_lock:
+        _domain_failures[domain] = 0 if succeeded else _domain_failures.get(domain, 0) + 1
+
+
+def select_image_dir(primary_dir, overflow_dir, min_free_bytes, force_overflow=False):
+    if force_overflow:
+        overflow_dir.mkdir(parents=True, exist_ok=True)
+        overflow_free = shutil.disk_usage(overflow_dir.anchor).free
+        if overflow_free < min_free_bytes:
+            raise OSError(
+                f"overflow volume is below the safety threshold: "
+                f"overflow_free={overflow_free}, threshold={min_free_bytes}"
+            )
+        return overflow_dir
+    primary_free = shutil.disk_usage(primary_dir.anchor).free
+    if primary_free >= min_free_bytes:
+        return primary_dir
+    overflow_dir.mkdir(parents=True, exist_ok=True)
+    overflow_free = shutil.disk_usage(overflow_dir.anchor).free
+    if overflow_free < min_free_bytes:
+        raise OSError(
+            f"both storage volumes are below the safety threshold: "
+            f"primary_free={primary_free}, overflow_free={overflow_free}, "
+            f"threshold={min_free_bytes}"
+        )
+    notice_key = str(overflow_dir)
+    with _storage_notice_lock:
+        if notice_key not in _storage_notice_emitted:
+            logging.warning(
+                "storage_switch primary=%s primary_free_gb=%.2f overflow=%s overflow_free_gb=%.2f threshold_gb=%.2f",
+                primary_dir,
+                primary_free / (1024 ** 3),
+                overflow_dir,
+                overflow_free / (1024 ** 3),
+                min_free_bytes / (1024 ** 3),
+            )
+            _storage_notice_emitted.add(notice_key)
+    return overflow_dir
+
+
+def retry_one(record, primary_image_dir, overflow_image_dir, min_free_bytes, existing_index, force_overflow):
+    url = record["url"]
+    reused = existing_index.get(image_stem(url))
+    if reused:
+        return {**record, "status": "ok", "local_path": str(reused), "bytes": reused.stat().st_size, "error": None, "retry_attempts": 0, "reused": True}
+    if domain_is_open(url):
+        return {**record, "status": "failed", "local_path": None, "bytes": 0, "error": "domain_circuit_open", "retry_attempts": 0, "reused": False}
+
+    image_dir = select_image_dir(primary_image_dir, overflow_image_dir, min_free_bytes, force_overflow)
+    partial = image_dir / (image_stem(url) + ".retry.part")
+    last_error = ""
+    max_attempts = attempts_for_error(record)
+    for attempt in range(1, max_attempts + 1):
+        for request_url in request_urls(url):
+            try:
+                partial.unlink(missing_ok=True)
+                command = [
+                    "curl.exe", "--location", "--fail", "--silent", "--show-error",
+                    "--connect-timeout", str(CONNECT_TIMEOUT), "--max-time", str(MAX_TIME),
+                    "--user-agent", "GeoAgent research image retry/1.0",
+                    "--referer", "https://www.reddit.com/",
+                    "--header", "Accept: image/avif,image/webp,image/apng,image/*,*/*;q=0.8",
+                    "--output", str(partial), request_url,
+                ]
+                result = subprocess.run(command, capture_output=True, text=True, timeout=MAX_TIME + 10)
+                actual = detected_extension(partial) if partial.exists() else None
+                if result.returncode == 0 and actual:
+                    final_path = image_dir / (image_stem(url) + actual)
+                    partial.replace(final_path)
+                    existing_index[image_stem(url)] = final_path
+                    update_domain_health(url, True)
+                    return {**record, "status": "ok", "local_path": str(final_path), "bytes": final_path.stat().st_size, "error": None, "retry_attempts": attempt, "reused": False}
+                last_error = (result.stderr or "not_a_supported_image").strip()[-500:]
+                if error_kind(last_error) in {"http_404", "http_403", "http_4xx", "http_429", "http_5xx", "malformed_url"}:
+                    break
+            except subprocess.TimeoutExpired as exc:
+                last_error = str(exc)[-500:]
+            except (OSError, ValueError, TypeError) as exc:
+                return {**record, "status": "internal_error", "local_path": None, "bytes": 0, "error": str(exc)[-500:], "retry_attempts": attempt, "reused": False}
+        if attempt < max_attempts:
+            kind = error_kind(last_error)
+            time.sleep(5 if kind == "http_429" else (2 ** (attempt - 1)))
+    partial.unlink(missing_ok=True)
+    update_domain_health(url, False)
+    return {**record, "status": "failed", "local_path": None, "bytes": 0, "error": last_error or "retry_failed", "retry_attempts": max_attempts, "reused": False}
+
+
+def read_manifest(path):
+    with path.open("r", encoding="utf-8") as handle:
+        for line in handle:
+            if line.strip():
+                yield json.loads(line)
+
+
+def write_jsonl(path, records):
+    temporary = path.with_suffix(path.suffix + ".part")
+    with temporary.open("w", encoding="utf-8") as handle:
+        for record in records:
+            handle.write(json.dumps(record, ensure_ascii=False, separators=(",", ":")) + "\n")
+    temporary.replace(path)
+
+
+def process_community(name, workers, retry_all, restart, overflow_root, state_root, min_free_gb, force_overflow, limit=None):
+    community_dir = OUT_ROOT / name
+    manifest_path = community_dir / "image_manifest.jsonl"
+    image_dir = community_dir / "images"
+    overflow_image_dir = overflow_root / name / "images"
+    min_free_bytes = int(min_free_gb * 1024 ** 3)
+    state_dir = state_root / name
+    state_dir.mkdir(parents=True, exist_ok=True)
+    checkpoint_path = state_dir / "retry_state.jsonl"
+    output_path = state_dir / "image_manifest_retry.jsonl"
+    log_path = state_dir / "retry_failed_images.log"
+    logging.basicConfig(filename=log_path, level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s", force=True)
+
+    records = list(read_manifest(manifest_path))
+    existing_index = build_existing_index([image_dir, overflow_image_dir])
+    record_by_url = {record["url"]: record for record in records}
+    candidates = [record for record in records if record.get("status") == "failed" and should_retry(record, retry_all)]
+    if limit is not None:
+        candidates = candidates[:limit]
+    checkpoint = {}
+    if checkpoint_path.exists() and not restart:
+        checkpoint = {record["url"]: record for record in read_manifest(checkpoint_path)}
+    pending = [record for record in candidates if record["url"] not in checkpoint]
+    logging.info("prepared community=%s candidates=%s checkpoint=%s pending=%s existing_images=%s retry_all=%s", name, len(candidates), len(checkpoint), len(pending), len(existing_index), retry_all)
+    print(json.dumps({"community": name, "candidates": len(candidates), "checkpoint": len(checkpoint), "pending": len(pending)}, ensure_ascii=False), flush=True)
+
+    checkpoint_path.parent.mkdir(parents=True, exist_ok=True)
+    checkpoint_handle = checkpoint_path.open("w" if restart else "a", encoding="utf-8")
+    ok = sum(record.get("status") == "ok" for record in checkpoint.values())
+    failed = sum(record.get("status") == "failed" for record in checkpoint.values())
+    started = time.time()
+    internal_errors = 0
+    try:
+        for offset in range(0, len(pending), BATCH_SIZE):
+            batch = pending[offset:offset + BATCH_SIZE]
+            with ThreadPoolExecutor(max_workers=max(1, workers)) as executor:
+                futures = [
+                    executor.submit(retry_one, record, image_dir, overflow_image_dir, min_free_bytes, existing_index, force_overflow)
+                    for record in batch
+                ]
+                for future in as_completed(futures):
+                    result = future.result()
+                    if result.get("status") == "internal_error":
+                        internal_errors += 1
+                        raise RuntimeError(f"internal downloader error for {result['url']}: {result.get('error')}")
+                    checkpoint[result["url"]] = result
+                    checkpoint_handle.write(json.dumps(result, ensure_ascii=False, separators=(",", ":")) + "\n")
+                    checkpoint_handle.flush()
+                    if result["status"] == "ok":
+                        ok += 1
+                    else:
+                        failed += 1
+            completed = len(checkpoint)
+            speed = completed / max(time.time() - started, 0.001)
+            logging.info("progress=%s/%s ok=%s failed=%s speed=%.2f records/s", completed, len(candidates), ok, failed, speed)
+            print(json.dumps({"community": name, "progress": completed, "total": len(candidates), "ok": ok, "failed": failed, "speed": round(speed, 3)}, ensure_ascii=False), flush=True)
+    finally:
+        checkpoint_handle.close()
+
+    merged = []
+    for record in records:
+        merged.append(checkpoint.get(record["url"], record))
+    write_jsonl(output_path, merged)
+    final = {"community": name, "status": "complete", "candidates": len(candidates), "retried": len(checkpoint), "retry_ok": ok, "retry_failed": failed, "output": str(output_path)}
+    logging.info("complete %s", json.dumps(final, ensure_ascii=False))
+    print(json.dumps(final, ensure_ascii=False), flush=True)
+    return final
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Retry failed image downloads without modifying the original manifests")
+    parser.add_argument("--communities", nargs="+", choices=["whereisthis", "GeoPuzzle", "PictureGame"], default=["whereisthis", "GeoPuzzle", "PictureGame"])
+    parser.add_argument("--workers", type=int, default=DEFAULT_WORKERS)
+    parser.add_argument("--retry-all", action="store_true", help="also retry HTTP 404, 403 and malformed URLs")
+    parser.add_argument("--restart", action="store_true", help="ignore retry_state.jsonl and retry selected failures again")
+    parser.add_argument("--limit", type=int, help="process only the first N candidates per community for validation")
+    parser.add_argument("--overflow-root", type=Path, default=DEFAULT_OVERFLOW_ROOT, help="secondary image root used when the primary volume is low")
+    parser.add_argument("--state-root", type=Path, default=DEFAULT_STATE_ROOT, help="root for logs, checkpoints and merged retry manifests")
+    parser.add_argument("--force-overflow", action="store_true", help="always write new images to the overflow root")
+    parser.add_argument("--min-free-gb", type=float, default=DEFAULT_MIN_FREE_GB, help="switch volumes when free space is below this threshold")
+    args = parser.parse_args()
+    if not isinstance(MAX_TIME, int) or not isinstance(CONNECT_TIMEOUT, int):
+        raise TypeError("timeout constants must be integers")
+    if args.min_free_gb <= 0:
+        raise ValueError("--min-free-gb must be greater than zero")
+    summaries = [
+        process_community(name, args.workers, args.retry_all, args.restart, args.overflow_root, args.state_root, args.min_free_gb, args.force_overflow, args.limit)
+        for name in args.communities
+    ]
+    print(json.dumps({"status": "complete", "communities": summaries}, ensure_ascii=False), flush=True)
+
+
+if __name__ == "__main__":
+    main()

reddit/_rescue_20260917/raw/scripts/retry_recoverable_284.py

@@ -0,0 +1,118 @@
+"""Retry the recoverable subset left by retry_circuit_skipped.py."""
+
+import argparse
+import json
+import logging
+import re
+import threading
+import time
+from collections import defaultdict
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from urllib.parse import urlparse
+
+import retry_failed_images as downloader
+
+
+def latest_records(path):
+    records = {}
+    for record in downloader.read_manifest(path):
+        records[record["url"]] = record
+    return records
+
+
+def recoverable(error):
+    text = error or ""
+    return bool(
+        "429" in text
+        or "Empty reply" in text
+        or re.search(r"\b5\d\d\b", text)
+        or "timed out" in text.lower()
+        or "timeout" in text.lower()
+        or any(token in text for token in ("SSL", "TLS", "schannel", "handshake"))
+    )
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--source", type=Path, default=Path(r"C:\GeoAgent_reddit_overflow\retry_state\PictureGame\circuit_retry_state.jsonl"))
+    parser.add_argument("--workers", type=int, default=4)
+    parser.add_argument("--attempts", type=int, default=3)
+    parser.add_argument("--connect-timeout", type=int, default=20)
+    parser.add_argument("--max-time", type=int, default=60)
+    parser.add_argument("--domain-delay", type=float, default=3.0)
+    parser.add_argument("--min-free-gb", type=float, default=5.0)
+    parser.add_argument("--limit", type=int)
+    parser.add_argument("--restart", action="store_true")
+    args = parser.parse_args()
+
+    community = "PictureGame"
+    primary_dir = downloader.OUT_ROOT / community / "images"
+    overflow_dir = downloader.DEFAULT_OVERFLOW_ROOT / community / "images"
+    state_dir = downloader.DEFAULT_STATE_ROOT / community
+    state_dir.mkdir(parents=True, exist_ok=True)
+    state_path = state_dir / "recoverable_284_state.jsonl"
+    log_path = state_dir / "recoverable_284.log"
+    output_path = state_dir / "image_manifest_recoverable_284.jsonl"
+    logging.basicConfig(filename=log_path, level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s", force=True)
+
+    candidates = [r for r in latest_records(args.source).values() if r.get("status") == "failed" and recoverable(r.get("error"))]
+    candidates.sort(key=lambda r: (urlparse(r["url"]).netloc.lower(), r["url"]))
+    if args.limit is not None:
+        candidates = candidates[:args.limit]
+    checkpoint = latest_records(state_path) if state_path.exists() and not args.restart else {}
+    pending = [r for r in candidates if r["url"] not in checkpoint]
+
+    downloader.ATTEMPTS = args.attempts
+    downloader.CONNECT_TIMEOUT = args.connect_timeout
+    downloader.MAX_TIME = args.max_time
+    downloader.domain_is_open = lambda _url: False
+    downloader.update_domain_health = lambda _url, _succeeded: None
+    existing = downloader.build_existing_index([primary_dir, overflow_dir])
+    minimum = int(args.min_free_gb * 1024 ** 3)
+    domain_locks = defaultdict(lambda: threading.BoundedSemaphore(1))
+    domain_last_request = defaultdict(float)
+    timing_lock = threading.Lock()
+
+    def retry(record):
+        domain = urlparse(record["url"]).netloc.lower()
+        with domain_locks[domain]:
+            with timing_lock:
+                wait = args.domain_delay - (time.monotonic() - domain_last_request[domain])
+            if wait > 0:
+                time.sleep(wait)
+            result = downloader.retry_one(record, primary_dir, overflow_dir, minimum, existing, True)
+            with timing_lock:
+                domain_last_request[domain] = time.monotonic()
+            return result
+
+    logging.info("prepared candidates=%s checkpoint=%s pending=%s", len(candidates), len(checkpoint), len(pending))
+    print(json.dumps({"candidates": len(candidates), "checkpoint": len(checkpoint), "pending": len(pending)}, ensure_ascii=False), flush=True)
+    mode = "w" if args.restart else "a"
+    ok = sum(r.get("status") == "ok" for r in checkpoint.values())
+    failed = sum(r.get("status") == "failed" for r in checkpoint.values())
+    started = time.time()
+    with state_path.open(mode, encoding="utf-8") as handle, ThreadPoolExecutor(max_workers=args.workers) as pool:
+        futures = [pool.submit(retry, record) for record in pending]
+        for index, future in enumerate(as_completed(futures), 1):
+            result = future.result()
+            if result.get("status") == "internal_error":
+                raise RuntimeError(result.get("error"))
+            checkpoint[result["url"]] = result
+            handle.write(json.dumps(result, ensure_ascii=False, separators=(",", ":")) + "\n")
+            handle.flush()
+            ok += result.get("status") == "ok"
+            failed += result.get("status") == "failed"
+            if index % 10 == 0 or index == len(pending):
+                speed = index / max(time.time() - started, 0.001)
+                logging.info("progress=%s/%s ok=%s failed=%s speed=%.3f records/s", len(checkpoint), len(candidates), ok, failed, speed)
+                print(json.dumps({"progress": len(checkpoint), "total": len(candidates), "ok": ok, "failed": failed, "speed": round(speed, 3)}), flush=True)
+
+    downloader.write_jsonl(output_path, checkpoint.values())
+    final = {"status": "complete", "candidates": len(candidates), "ok": ok, "failed": failed, "output": str(output_path)}
+    logging.info("complete %s", json.dumps(final, ensure_ascii=False))
+    print(json.dumps(final, ensure_ascii=False), flush=True)
+
+
+if __name__ == "__main__":
+    main()

reddit/_rescue_20260917/raw/scripts/run_canonical_reddit_upload.ps1

@@ -0,0 +1,51 @@
+$ErrorActionPreference = 'Stop'
+
+$pythonExe = 'C:\Users\zong zilu\AppData\Local\Programs\Python\Python313\python.exe'
+$uploader = 'D:\GeoAgent\Geo-CoT dataset\外网图像地理定位数据收集\reddit_posts\upload_reddit_images_batched.py'
+$cacheRoot = 'C:\GeoAgent_hf_upload_cache\reddit\canonical_upload'
+$nativeArgs = @(
+    $uploader
+    'upload'
+    '--cache-root'
+    $cacheRoot
+    '--revision'
+    'reddit'
+    '--communities'
+    'whereisthis'
+    'GeoPuzzle'
+    'PictureGame'
+    '--batch-size'
+    '10000'
+    '--max-batch-bytes'
+    '5368709120'
+    '--upload-threads'
+    '6'
+    '--request-timeout'
+    '180'
+    '--batch-retries'
+    '3'
+    '--retry-backoff-seconds'
+    '10'
+    '--rate-limit-poll-seconds'
+    '300'
+    '--heartbeat-seconds'
+    '30'
+    '--min-c-free-gib'
+    '5'
+    '--min-d-free-gib'
+    '2'
+    '--hard-c-floor-gib'
+    '1'
+    '--hard-d-floor-gib'
+    '2'
+)
+
+& $pythonExe @nativeArgs
+$exitCode = $LASTEXITCODE
+$statusPath = Join-Path $cacheRoot 'process_exit.json'
+$payload = [ordered]@{
+    exited_at = [DateTimeOffset]::Now.ToUnixTimeSeconds()
+    exit_code = $exitCode
+}
+$payload | ConvertTo-Json | Set-Content -LiteralPath $statusPath -Encoding utf8
+exit $exitCode

reddit/_rescue_20260917/raw/scripts/start_picturegame.ps1

@@ -0,0 +1,19 @@
+$ErrorActionPreference = 'Stop'
+
+$scriptPath = Join-Path $PSScriptRoot 'organize_three_communities.py'
+$pythonExe = (Get-Command python.exe -ErrorAction Stop).Source
+
+$psi = [System.Diagnostics.ProcessStartInfo]::new()
+$psi.FileName = $pythonExe
+$psi.WorkingDirectory = $PSScriptRoot
+$psi.UseShellExecute = $false
+$psi.CreateNoWindow = $true
+$psi.RedirectStandardOutput = $false
+$psi.RedirectStandardError = $false
+$psi.ArgumentList.Add('-u')
+$psi.ArgumentList.Add($scriptPath)
+$psi.ArgumentList.Add('--communities')
+$psi.ArgumentList.Add('PictureGame')
+
+$process = [System.Diagnostics.Process]::Start($psi)
+Write-Output ("started_pid=" + $process.Id)

reddit/_rescue_20260917/raw/scripts/start_retry_failed.ps1

@@ -0,0 +1,20 @@
+$ErrorActionPreference = 'Stop'
+
+$workDir = $PSScriptRoot
+$pythonExe = (Get-Command python.exe -ErrorAction Stop).Source
+$scriptPath = Join-Path $workDir 'retry_failed_images.py'
+$stdoutPath = Join-Path $workDir 'retry_failed_runner.stdout.log'
+$stderrPath = Join-Path $workDir 'retry_failed_runner.stderr.log'
+
+$psi = [System.Diagnostics.ProcessStartInfo]::new()
+$psi.FileName = $pythonExe
+$psi.WorkingDirectory = $workDir
+$psi.UseShellExecute = $false
+$psi.CreateNoWindow = $true
+$psi.RedirectStandardOutput = $false
+$psi.RedirectStandardError = $false
+$psi.ArgumentList.Add('-u')
+$psi.ArgumentList.Add($scriptPath)
+$process = [System.Diagnostics.Process]::Start($psi)
+
+Write-Output ("started_pid=" + $process.Id)

reddit/_rescue_20260917/raw/scripts/test_upload_canonical_reddit_images.py

@@ -0,0 +1,130 @@
+"""Upload one canonical image per community in a single verified commit."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import time
+from pathlib import Path
+
+# Configure direct networking before importing huggingface_hub, whose global
+# client may otherwise retain the machine proxy settings.
+for _proxy_key in ("HTTPS_PROXY", "HTTP_PROXY", "ALL_PROXY", "https_proxy", "http_proxy", "all_proxy"):
+    os.environ.pop(_proxy_key, None)
+
+import httpx
+from huggingface_hub import CommitOperationAdd, HfApi, set_client_factory
+
+
+COMMUNITIES = ("whereisthis", "GeoPuzzle", "PictureGame")
+
+
+def jsonl(path: Path):
+    with path.open("r", encoding="utf-8") as handle:
+        for line in handle:
+            if line.strip():
+                yield json.loads(line)
+
+
+def configure_direct_client() -> None:
+    def factory() -> httpx.Client:
+        return httpx.Client(
+            follow_redirects=True,
+            trust_env=False,
+            timeout=httpx.Timeout(120.0, connect=30.0, pool=30.0),
+        )
+    set_client_factory(factory)
+
+
+def retry_network(operation, label: str):
+    for attempt in range(1, 4):
+        try:
+            return operation()
+        except Exception as exc:
+            status = getattr(getattr(exc, "response", None), "status_code", None)
+            if status == 429:
+                raise RuntimeError(f"rate_limited_429 during {label}; stop and probe after 300 seconds") from exc
+            if attempt == 3:
+                raise
+            delay = 5 * (2 ** (attempt - 1))
+            print(f"network_retry label={label} attempt={attempt}/3 delay={delay}s error={type(exc).__name__}", flush=True)
+            time.sleep(delay)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--manifest", type=Path, required=True)
+    parser.add_argument("--naming-map", type=Path, required=True)
+    parser.add_argument("--state", type=Path, required=True)
+    args = parser.parse_args()
+    configure_direct_client()
+    free_c = shutil.disk_usage("C:\\").free
+    free_d = shutil.disk_usage("D:\\").free
+    if free_c < 5 * 1024**3 or free_d < 2 * 1024**3:
+        raise RuntimeError(f"storage floor reached: C={free_c} D={free_d}")
+
+    selected = {}
+    for row in jsonl(args.manifest):
+        if row["community"] in COMMUNITIES and row["status"] == "valid" and row["is_canonical"] and row["community"] not in selected:
+            selected[row["community"]] = row
+    if set(selected) != set(COMMUNITIES):
+        raise RuntimeError(f"missing test community: {set(COMMUNITIES) - set(selected)}")
+    invalid_names = [row["canonical_path"] for row in selected.values() if "_unlinked_" in row["canonical_path"]]
+    if invalid_names:
+        raise RuntimeError(f"unlinked canonical names are forbidden: {invalid_names}")
+    source_by_old = {}
+    for row in jsonl(args.naming_map):
+        source_by_old[row["old_remote_path"]] = row["local_path"]
+
+    api = HfApi()
+    revision = "reddit"
+    repo_id = "Geo-Club/Geo-Video"
+    operations = []
+    results = []
+    for community in COMMUNITIES:
+        row = selected[community]
+        source = Path(source_by_old[row["original_path"]])
+        if not source.is_file() or source.stat().st_size != row["size"]:
+            raise RuntimeError(f"source missing/changed: {source}")
+        exists_before = retry_network(
+            lambda row=row: api.file_exists(repo_id=repo_id, filename=row["canonical_path"], repo_type="dataset", revision=revision),
+            f"exists_before:{community}",
+        )
+        if not exists_before:
+            operations.append(CommitOperationAdd(path_in_repo=row["canonical_path"], path_or_fileobj=str(source)))
+        results.append({"community": community, "source": str(source), "remote_path": row["canonical_path"], "size": row["size"], "sha256": row["sha256"], "exists_before": exists_before})
+    commit_sha = None
+    if operations:
+        info = retry_network(
+            lambda: api.create_commit(repo_id=repo_id, repo_type="dataset", revision=revision, operations=operations, commit_message="Test canonical Reddit image paths (3 communities)"),
+            "create_test_commit",
+        )
+        commit_sha = info.oid
+    for row in results:
+        row["exists_after"] = retry_network(
+            lambda row=row: api.file_exists(repo_id=repo_id, filename=row["remote_path"], repo_type="dataset", revision=revision),
+            f"exists_after:{row['community']}",
+        )
+    passed = all(x["exists_after"] for x in results)
+    payload = {
+        "status": "passed" if passed else "failed",
+        "created_at": time.time(),
+        "repo_id": repo_id,
+        "revision": revision,
+        "commit_sha": commit_sha,
+        "operations": len(operations),
+        "local_image_copies_created": 0,
+        "c_free_gib": round(shutil.disk_usage("C:\\").free / 1024**3, 2),
+        "d_free_gib": round(shutil.disk_usage("D:\\").free / 1024**3, 2),
+        "files": results,
+    }
+    args.state.parent.mkdir(parents=True, exist_ok=True)
+    args.state.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+    print(json.dumps(payload, ensure_ascii=False), flush=True)
+    return 0 if passed else 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

reddit/_rescue_20260917/raw/scripts/upload_reddit_images_batched.py

@@ -0,0 +1,1012 @@
+"""Batch-upload already downloaded Reddit images to Hugging Face.
+
+The source image directories are read in place and are never moved, renamed,
+or modified. Only inventory, state, manifests, and logs are written below the
+C: drive cache directory.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import logging
+import os
+import shutil
+import sys
+import threading
+import time
+import uuid
+from collections import Counter
+from pathlib import Path
+
+os.environ.setdefault("HF_HUB_DISABLE_PROGRESS_BARS", "1")
+os.environ.setdefault("HF_HUB_DISABLE_XET", "1")
+
+# Long uploads on this machine are more reliable over a direct connection.
+# This changes only the uploader process, not the user's system settings.
+for _proxy_var in (
+    "HTTPS_PROXY",
+    "HTTP_PROXY",
+    "ALL_PROXY",
+    "https_proxy",
+    "http_proxy",
+    "all_proxy",
+):
+    os.environ.pop(_proxy_var, None)
+
+# The machine-wide HTTPS proxy has repeatedly dropped long S3 PUT requests.
+# Both endpoints are directly reachable, so bypass the proxy only for this
+# uploader process while leaving the user's system proxy untouched.
+_direct_hosts = "huggingface.co,.huggingface.co,amazonaws.com,.amazonaws.com"
+for _proxy_var in ("NO_PROXY", "no_proxy"):
+    _existing_no_proxy = os.environ.get(_proxy_var, "")
+    _entries = [entry.strip() for entry in _existing_no_proxy.split(",") if entry.strip()]
+    for _host in _direct_hosts.split(","):
+        if _host not in _entries:
+            _entries.append(_host)
+    os.environ[_proxy_var] = ",".join(_entries)
+
+import httpx
+from huggingface_hub import CommitOperationAdd, HfApi, hf_hub_url, set_client_factory
+from huggingface_hub.utils._http import default_client_factory
+from huggingface_hub.utils import HfHubHTTPError
+
+
+DEFAULT_REPO_ID = "Geo-Club/Geo-Video"
+DEFAULT_REVISION = "reddit"
+DEFAULT_SOURCE_ROOT = Path(
+    r"D:\GeoAgent\Geo-CoT dataset\外网图像地理定位数据收集\reddit_posts\solved_communities"
+)
+DEFAULT_OVERFLOW_ROOT = Path(r"C:\GeoAgent_reddit_overflow\solved_communities")
+DEFAULT_CACHE_ROOT = Path(r"C:\GeoAgent_hf_upload_cache\reddit")
+COMMUNITIES = ("whereisthis", "GeoPuzzle", "PictureGame")
+# Hugging Face limits the number of files in a single repository directory.
+# Keep a safety margin below the hard 10,000-file limit.
+REMOTE_SHARD_SIZE = 9000
+
+
+def configure_http_client(timeout_seconds: float) -> None:
+    """Replace huggingface_hub's unbounded default timeout."""
+
+    def factory() -> httpx.Client:
+        return httpx.Client(
+            follow_redirects=True,
+            trust_env=False,
+            timeout=httpx.Timeout(
+                timeout_seconds,
+                connect=min(timeout_seconds, 30.0),
+                pool=min(timeout_seconds, 30.0),
+            ),
+        )
+
+    set_client_factory(factory)
+
+
+def setup_logging(cache_root: Path, verbose: bool = False) -> logging.Logger:
+    cache_root.mkdir(parents=True, exist_ok=True)
+    logger = logging.getLogger("reddit_hf_upload")
+    logger.setLevel(logging.DEBUG)
+    logger.handlers.clear()
+    formatter = logging.Formatter("%(asctime)s %(levelname)s %(message)s")
+    file_handler = logging.FileHandler(cache_root / "upload.log", encoding="utf-8")
+    file_handler.setFormatter(formatter)
+    file_handler.setLevel(logging.DEBUG)
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setFormatter(formatter)
+    console_handler.setLevel(logging.DEBUG if verbose else logging.INFO)
+    logger.addHandler(file_handler)
+    logger.addHandler(console_handler)
+    return logger
+
+
+def acquire_upload_lock(cache_root: Path, logger: logging.Logger):
+    """Acquire the uploader singleton lock without deleting unknown locks."""
+    cache_root.mkdir(parents=True, exist_ok=True)
+    lock_path = cache_root / "upload.lock"
+    token = uuid.uuid4().hex
+    payload = {
+        "pid": os.getpid(),
+        "started_at": time.time(),
+        "token": token,
+        "command": "upload",
+    }
+    try:
+        handle = lock_path.open("x", encoding="utf-8")
+    except FileExistsError:
+        details = None
+        try:
+            details = json.loads(lock_path.read_text(encoding="utf-8"))
+        except Exception as exc:
+            logger.error(
+                "upload_lock_refused path=%s reason=unreadable_existing_lock error=%s",
+                lock_path,
+                exc,
+            )
+            raise RuntimeError(f"Cannot verify existing upload lock: {lock_path}") from exc
+        owner_pid = details.get("pid")
+        owner_alive = False
+        if isinstance(owner_pid, int) and owner_pid > 0:
+            try:
+                os.kill(owner_pid, 0)
+                owner_alive = True
+            except ProcessLookupError:
+                owner_alive = False
+            except PermissionError:
+                # Access denied still proves that a Windows process owns the PID.
+                owner_alive = True
+            except OSError:
+                owner_alive = False
+        if owner_alive:
+            logger.error(
+                "upload_lock_refused path=%s reason=active_owner owner_pid=%s started_at=%s",
+                lock_path,
+                owner_pid,
+                details.get("started_at"),
+            )
+            raise RuntimeError(f"Another uploader is active (pid={owner_pid})")
+        logger.error(
+            "upload_lock_refused path=%s reason=stale_or_unverifiable_lock owner_pid=%s started_at=%s action=manual_review_required",
+            lock_path,
+            owner_pid,
+            details.get("started_at"),
+        )
+        raise RuntimeError(f"Stale or unverifiable upload lock requires manual review: {lock_path}")
+    except OSError as exc:
+        logger.error("upload_lock_refused path=%s reason=create_failed error=%s", lock_path, exc)
+        raise
+
+    try:
+        try:
+            handle.write(json.dumps(payload, ensure_ascii=False, separators=(",", ":")))
+            handle.flush()
+            os.fsync(handle.fileno())
+        finally:
+            handle.close()
+    except Exception:
+        try:
+            lock_path.unlink()
+        except OSError:
+            logger.exception("upload_lock_cleanup_failed path=%s", lock_path)
+        raise
+    logger.info("upload_lock_acquired path=%s pid=%s", lock_path, os.getpid())
+
+    def release() -> None:
+        try:
+            current = json.loads(lock_path.read_text(encoding="utf-8"))
+        except Exception:
+            logger.warning("upload_lock_preserved path=%s reason=ownership_check_failed", lock_path)
+            return
+        if current.get("token") != token or current.get("pid") != os.getpid():
+            logger.warning("upload_lock_preserved path=%s reason=ownership_mismatch", lock_path)
+            return
+        try:
+            lock_path.unlink()
+            logger.info("upload_lock_released path=%s", lock_path)
+        except FileNotFoundError:
+            pass
+        except OSError:
+            logger.exception("upload_lock_release_failed path=%s", lock_path)
+
+    return release
+
+
+def append_jsonl(path: Path, record: dict) -> None:
+    with path.open("a", encoding="utf-8") as handle:
+        handle.write(json.dumps(record, ensure_ascii=False, separators=(",", ":")) + "\n")
+
+
+def read_jsonl(path: Path):
+    if not path.exists():
+        return
+    with path.open("r", encoding="utf-8") as handle:
+        for line_number, line in enumerate(handle, 1):
+            if not line.strip():
+                continue
+            try:
+                yield json.loads(line)
+            except json.JSONDecodeError:
+                logging.getLogger("reddit_hf_upload").warning(
+                    "skip_invalid_json path=%s line=%s", path, line_number
+                )
+
+
+def image_files(root: Path, community: str) -> list[Path]:
+    image_root = root / community / "images"
+    if not image_root.exists():
+        return []
+    return sorted(
+        path
+        for path in image_root.rglob("*")
+        if path.is_file() and not path.name.endswith(".part") and path.stat().st_size > 0
+    )
+
+
+def sha256_file(path: Path, chunk_size: int = 1024 * 1024) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        while chunk := handle.read(chunk_size):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def build_inventory(args, logger: logging.Logger) -> list[dict]:
+    inventory_path = args.cache_root / "inventory.jsonl"
+    temp_path = inventory_path.with_suffix(".jsonl.part")
+    records: list[dict] = []
+    seen: dict[tuple[str, str], dict] = {}
+    source_roots = [args.source_root, args.overflow_root]
+
+    logger.info("inventory_start source_roots=%s", [str(root) for root in source_roots])
+    for community in args.communities:
+        discovered = 0
+        for root in source_roots:
+            for path in image_files(root, community):
+                discovered += 1
+                key = (community, path.name)
+                record = {
+                    "community": community,
+                    "filename": path.name,
+                    "local_path": str(path),
+                    "relative_path": None,
+                    "legacy_relative_path": f"reddit/images/{community}/{path.name}",
+                    "size": path.stat().st_size,
+                    "sha256": None,
+                }
+                previous = seen.get(key)
+                if previous is None:
+                    seen[key] = record
+                elif previous["size"] != record["size"]:
+                    logger.error(
+                        "duplicate_target_conflict community=%s filename=%s first=%s second=%s",
+                        community,
+                        path.name,
+                        previous["local_path"],
+                        path,
+                    )
+                else:
+                    logger.warning(
+                        "duplicate_target_same_size community=%s filename=%s skipped=%s",
+                        community,
+                        path.name,
+                        path,
+                    )
+        logger.info("inventory_community community=%s discovered=%s", community, discovered)
+
+    records = [seen[key] for key in sorted(seen)]
+    # Assign shards from the stable filename order. Rebuilding the inventory
+    # therefore produces the same remote path on every resume.
+    for community in args.communities:
+        community_records = [record for record in records if record["community"] == community]
+        for index, record in enumerate(community_records):
+            shard = index // REMOTE_SHARD_SIZE
+            record["shard"] = shard
+            record["relative_path"] = (
+                f"reddit/images/{community}/{shard:04d}/{record['filename']}"
+            )
+    with temp_path.open("w", encoding="utf-8") as handle:
+        for record in records:
+            handle.write(json.dumps(record, ensure_ascii=False, separators=(",", ":")) + "\n")
+    temp_path.replace(inventory_path)
+    summary = Counter(record["community"] for record in records)
+    total_bytes = sum(record["size"] for record in records)
+    summary_record = {
+        "created_at": time.time(),
+        "records": len(records),
+        "bytes": total_bytes,
+        "gib": round(total_bytes / (1024**3), 3),
+        "communities": dict(summary),
+    }
+    (args.cache_root / "inventory_summary.json").write_text(
+        json.dumps(summary_record, ensure_ascii=False, indent=2), encoding="utf-8"
+    )
+    logger.info(
+        "inventory_complete records=%s bytes=%s gib=%.3f communities=%s",
+        len(records),
+        total_bytes,
+        total_bytes / (1024**3),
+        dict(summary),
+    )
+    return records
+
+
+def load_inventory(args, logger: logging.Logger) -> list[dict]:
+    path = args.cache_root / "inventory.jsonl"
+    if not path.exists() or args.rebuild_inventory:
+        return build_inventory(args, logger)
+    records = list(read_jsonl(path))
+    logger.info("inventory_loaded records=%s path=%s", len(records), path)
+    return records
+
+
+def load_latest_state(args) -> dict[str, dict]:
+    latest: dict[str, dict] = {}
+    for record in read_jsonl(args.cache_root / "upload_state.jsonl") or ():
+        remote_path = record.get("remote_path") or record.get("relative_path")
+        if remote_path:
+            latest[remote_path] = record
+    return latest
+
+
+def remote_file_sizes(api: HfApi, args, logger: logging.Logger) -> dict[str, int]:
+    for attempt in range(1, args.batch_retries + 1):
+        try:
+            entries = api.list_repo_tree(
+                args.repo_id,
+                path_in_repo="reddit/images",
+                recursive=True,
+                revision=args.revision,
+                repo_type="dataset",
+            )
+            # This huggingface_hub version returns ``type=None`` for both files
+            # and folders; file entries expose a numeric size.
+            files = {
+                entry.path: int(entry.size)
+                for entry in entries
+                if getattr(entry, "size", None) is not None
+            }
+            logger.info("remote_inventory_complete files=%s bytes=%s", len(files), sum(files.values()))
+            return files
+        except Exception as exc:
+            # A missing directory is normal before the first image commit.
+            status_code = getattr(getattr(exc, "response", None), "status_code", None)
+            if exc.__class__.__name__ == "RemoteEntryNotFoundError" or status_code == 404:
+                logger.info("remote_inventory_empty path=reddit/images")
+                return {}
+            if attempt >= args.batch_retries:
+                logger.error("remote_inventory_failed attempts=%s error=%s", attempt, exc)
+                raise
+            delay = args.retry_backoff_seconds * (2 ** (attempt - 1))
+            logger.warning(
+                "remote_inventory_retry attempt=%s/%s delay_seconds=%.1f error=%s",
+                attempt,
+                args.batch_retries,
+                delay,
+                f"{type(exc).__name__}: {exc}"[-500:],
+            )
+            time.sleep(delay)
+
+
+def remote_files(api: HfApi, args, logger: logging.Logger) -> set[str]:
+    return set(remote_file_sizes(api, args, logger))
+
+
+def manifest_remote_path(record: dict, remote_sizes: dict[str, int]) -> str:
+    """Prefer an existing legacy path, otherwise use the sharded path."""
+    legacy = record["legacy_relative_path"]
+    current = record["relative_path"]
+    if remote_sizes.get(legacy) == record["size"]:
+        return legacy
+    return current
+
+
+def classify_error(exc: Exception) -> str:
+    status_code = getattr(getattr(exc, "response", None), "status_code", None)
+    text = f"{type(exc).__name__}: {exc}".lower()
+    if status_code == 429:
+        return "rate_limit_429"
+    if status_code in (401, 403):
+        return "permission_401_403"
+    if status_code == 404:
+        return "remote_404"
+    if status_code is not None and 500 <= status_code <= 599:
+        return "server_5xx"
+    if "timeout" in text or "timed out" in text:
+        return "connection_timeout"
+    if any(token in text for token in ("tls", "ssl", "certificate", "proxy")):
+        return "tls_or_proxy"
+    if any(token in text for token in ("size", "path", "filename")):
+        return "file_size_or_path"
+    return "network_or_unknown"
+
+
+def storage_snapshot(args) -> dict[str, float]:
+    return {
+        "c_free_gib": shutil.disk_usage(args.cache_root.anchor or "C:\\").free / (1024**3),
+        "d_free_gib": shutil.disk_usage(args.source_root.anchor or "D:\\").free / (1024**3),
+    }
+
+
+def storage_is_safe(args, logger: logging.Logger) -> bool:
+    snapshot = storage_snapshot(args)
+    safe = (
+        snapshot["c_free_gib"] >= args.min_c_free_gib
+        and snapshot["d_free_gib"] >= args.min_d_free_gib
+    )
+    logger.info(
+        "storage_check c_free_gib=%.2f d_free_gib=%.2f safe=%s thresholds=%.1f/%.1f",
+        snapshot["c_free_gib"],
+        snapshot["d_free_gib"],
+        int(safe),
+        args.min_c_free_gib,
+        args.min_d_free_gib,
+    )
+    return safe
+
+
+def storage_at_hard_floor(args, logger: logging.Logger) -> bool:
+    """Return true only when the hard stop floor is crossed."""
+    snapshot = storage_snapshot(args)
+    hard_stop = (
+        snapshot["c_free_gib"] < args.hard_c_floor_gib
+        or snapshot["d_free_gib"] < args.hard_d_floor_gib
+    )
+    logger.info(
+        "storage_hard_floor_check c_free_gib=%.2f d_free_gib=%.2f hard_stop=%s floors=%.1f/%.1f",
+        snapshot["c_free_gib"], snapshot["d_free_gib"], int(hard_stop),
+        args.hard_c_floor_gib, args.hard_d_floor_gib,
+    )
+    return hard_stop
+
+
+def cleanup_rebuildable_batch_cache(args, logger: logging.Logger) -> int:
+    """Remove only uploader-owned, rebuildable temporary files.
+
+    Images, inventories, state, manifests, and logs are deliberately excluded.
+    The uploader currently streams source files directly, so this is normally a
+    no-op, but it also handles interrupted future/library staging safely.
+    """
+    removed_bytes = 0
+    removed_files = 0
+    allowed_suffixes = {".part", ".tmp"}
+    rebuildable_names = {"large_folder_console_error.log"}
+    for path in args.cache_root.rglob("*"):
+        if not path.is_file() or path.name in {
+            "inventory.jsonl", "inventory_summary.json", "upload_state.jsonl",
+            "upload.log", "manifest_remote.jsonl", "manifest_remote_summary.json",
+        }:
+            continue
+        if path.suffix.lower() not in allowed_suffixes and path.name not in rebuildable_names:
+            continue
+        try:
+            size = path.stat().st_size
+            path.unlink()
+            removed_bytes += size
+            removed_files += 1
+            logger.info("batch_cache_removed path=%s bytes=%s", path, size)
+        except FileNotFoundError:
+            continue
+        except OSError as exc:
+            logger.warning("batch_cache_remove_failed path=%s error=%s", path, exc)
+    logger.info(
+        "batch_cache_cleanup_complete files=%s bytes=%s gib=%.3f",
+        removed_files, removed_bytes, removed_bytes / (1024**3),
+    )
+    return removed_files
+
+
+def wait_for_storage_recovery(args, logger: logging.Logger, reason: str) -> None:
+    """Keep the process alive until storage reaches the recovery watermark."""
+    cleanup_rebuildable_batch_cache(args, logger)
+    recovery_c = args.min_c_free_gib + args.storage_recovery_buffer_gib
+    recovery_d = args.min_d_free_gib + args.storage_recovery_buffer_gib
+    logger.warning(
+        "upload_waiting_for_storage reason=%s recovery_thresholds=%.2f/%.2f check_seconds=%.0f",
+        reason, recovery_c, recovery_d, args.storage_check_seconds,
+    )
+    while True:
+        snapshot = storage_snapshot(args)
+        recovered = (
+            snapshot["c_free_gib"] >= recovery_c
+            and snapshot["d_free_gib"] >= recovery_d
+        )
+        logger.info(
+            "storage_recovery_check c_free_gib=%.2f d_free_gib=%.2f recovered=%s",
+            snapshot["c_free_gib"], snapshot["d_free_gib"], int(recovered),
+        )
+        if recovered:
+            logger.info("storage_recovered action=resume_upload")
+            return
+        cleanup_rebuildable_batch_cache(args, logger)
+        time.sleep(args.storage_check_seconds)
+
+
+def select_records(records: list[dict], args, latest: dict[str, dict], remote: set[str]) -> list[dict]:
+    candidates = []
+    for record in records:
+        if record["community"] not in args.communities:
+            continue
+        # Remote state is authoritative. A stale local "uploaded" record must
+        # not hide a file that is absent from the selected branch.
+        if record["relative_path"] in remote or record["legacy_relative_path"] in remote:
+            continue
+        candidates.append({**record, "upload_path": record["relative_path"]})
+    if args.test:
+        selected = []
+        for community in args.communities:
+            selected.extend([item for item in candidates if item["community"] == community][: args.test_per_community])
+        return selected
+    if args.limit is not None:
+        return candidates[: args.limit]
+    return candidates
+
+
+def batched(records: list[dict], batch_size: int, max_batch_bytes: int):
+    batch: list[dict] = []
+    batch_bytes = 0
+    for record in records:
+        size = int(record["size"])
+        if batch and (len(batch) >= batch_size or batch_bytes + size > max_batch_bytes):
+            yield batch
+            batch = []
+            batch_bytes = 0
+        batch.append(record)
+        batch_bytes += size
+    if batch:
+        yield batch
+
+
+def community_batched(
+    records: list[dict],
+    communities: tuple[str, ...],
+    batch_size: int,
+    max_batch_bytes: int,
+):
+    """Yield large directory-like batches without mixing communities."""
+    for community in communities:
+        community_records = [record for record in records if record["community"] == community]
+        for batch in batched(community_records, batch_size, max_batch_bytes):
+            yield community, batch
+
+
+def estimate_batch_plan(
+    records: list[dict],
+    communities: tuple[str, ...],
+    batch_size: int,
+    max_batch_bytes: int,
+) -> dict[str, dict[str, int]]:
+    """Estimate commit count using the same rules as the actual batch planner."""
+    plan: dict[str, dict[str, int]] = {}
+    for community in communities:
+        community_records = [record for record in records if record["community"] == community]
+        batches = list(batched(community_records, batch_size, max_batch_bytes))
+        plan[community] = {
+            "files": len(community_records),
+            "bytes": sum(int(record["size"]) for record in community_records),
+            "batches": len(batches),
+        }
+    return plan
+
+
+def test_batched(records: list[dict], max_batch_bytes: int):
+    """Keep the three-file preflight in one commit while full batches stay isolated."""
+    if records:
+        yield "test-preflight", list(records)
+
+
+def upload_batch(api: HfApi, args, logger: logging.Logger, batch: list[dict], batch_number: int, state_path: Path):
+    started = time.time()
+    operations = []
+    valid_records = []
+    invalid_count = 0
+    for record in batch:
+        path = Path(record["local_path"])
+        if not path.exists() or path.stat().st_size != record["size"]:
+            append_jsonl(state_path, {**record, "revision": args.revision, "status": "failed", "error_category": "source_file_404", "error": "source_changed_or_missing", "batch": batch_number})
+            logger.error("source_invalid category=source_file_404 community=%s filename=%s path=%s", record["community"], record["filename"], path)
+            invalid_count += 1
+            continue
+        operations.append(CommitOperationAdd(path_in_repo=record["upload_path"], path_or_fileobj=path))
+        valid_records.append(record)
+    if not operations:
+        return 0, invalid_count, 0.0, None, 0
+
+    commit_sha = None
+    last_error = None
+    ordinary_attempt = 0
+    rate_limit_count = 0
+    while True:
+        ordinary_attempt += 1
+        stop_heartbeat = threading.Event()
+
+        def heartbeat() -> None:
+            while not stop_heartbeat.wait(args.heartbeat_seconds):
+                logger.info(
+                    "batch_heartbeat batch=%s attempt=%s files=%s bytes=%s elapsed=%.1fs",
+                    batch_number,
+                    ordinary_attempt,
+                    len(operations),
+                    sum(item["size"] for item in batch),
+                    time.time() - started,
+                )
+                snapshot = storage_snapshot(args)
+                logger.info(
+                    "batch_storage_heartbeat batch=%s c_free_gib=%.2f d_free_gib=%.2f",
+                    batch_number,
+                    snapshot["c_free_gib"],
+                    snapshot["d_free_gib"],
+                )
+
+        heartbeat_thread = threading.Thread(target=heartbeat, daemon=True)
+        heartbeat_thread.start()
+        try:
+            logger.info(
+                "batch_start batch=%s attempt=%s/%s files=%s bytes=%s",
+                batch_number,
+                ordinary_attempt,
+                args.batch_retries,
+                len(operations),
+                sum(item["size"] for item in batch),
+            )
+            info = api.create_commit(
+                repo_id=args.repo_id,
+                operations=operations,
+                commit_message=f"Add Reddit images batch {batch_number:06d}",
+                repo_type="dataset",
+                revision=args.revision,
+                num_threads=args.upload_threads,
+            )
+            commit_sha = getattr(info, "oid", None)
+            last_error = None
+            break
+        except Exception as exc:
+            last_error = exc
+            status_code = getattr(getattr(exc, "response", None), "status_code", None)
+            category = classify_error(exc)
+            logger.warning(
+                "batch_attempt_failed batch=%s attempt=%s/%s category=%s error=%s",
+                batch_number,
+                ordinary_attempt,
+                args.batch_retries,
+                category,
+                f"{type(exc).__name__}: {exc}"[-1000:],
+                exc_info=True,
+            )
+            if status_code == 429:
+                rate_limit_count += 1
+                delay = args.rate_limit_poll_seconds
+                ordinary_attempt -= 1
+                logger.warning(
+                    "commit_rate_limited batch=%s rate_limit_count=%s retry_is_not_permanent_failure=1 probe_in_seconds=%.0f server=%s",
+                    batch_number,
+                    rate_limit_count,
+                    delay,
+                    str(exc)[-500:],
+                )
+            elif ordinary_attempt < args.batch_retries:
+                delay = args.retry_backoff_seconds * (2 ** (ordinary_attempt - 1))
+            else:
+                delay = None
+            if delay is None:
+                break
+            logger.info("batch_retry_wait batch=%s seconds=%.1f", batch_number, delay)
+            time.sleep(delay)
+            if status_code == 429:
+                try:
+                    api.repo_info(args.repo_id, repo_type="dataset", revision=args.revision)
+                    logger.info("rate_limit_plan_only_probe batch=%s result=read_api_ok", batch_number)
+                except Exception as probe_exc:
+                    logger.warning("rate_limit_plan_only_probe batch=%s result=failed error=%s", batch_number, str(probe_exc)[-500:])
+        finally:
+            stop_heartbeat.set()
+            heartbeat_thread.join(timeout=2)
+
+    if last_error is None and commit_sha:
+        elapsed = max(time.time() - started, 0.001)
+        speed = len(operations) / elapsed
+        for record in valid_records:
+            append_jsonl(state_path, {**record, "remote_path": record["upload_path"], "revision": args.revision, "status": "uploaded", "error_category": None, "error": None, "batch": batch_number, "commit_sha": commit_sha, "sha256": record.get("sha256") or sha256_file(Path(record["local_path"])), "uploaded_at": time.time()})
+        logger.info(
+            "batch_complete batch=%s community=%s files=%s failed=%s bytes=%s elapsed=%.1fs speed=%.2f files_per_sec commit=%s",
+            batch_number,
+            batch[0]["community"],
+            len(operations),
+            invalid_count,
+            sum(item["size"] for item in batch),
+            elapsed,
+            speed,
+            commit_sha,
+        )
+        return len(operations), invalid_count, speed, commit_sha, rate_limit_count
+    else:
+        elapsed = max(time.time() - started, 0.001)
+        category = classify_error(last_error)
+        error = f"{type(last_error).__name__}: {last_error}"[-1000:]
+        for record in valid_records:
+            append_jsonl(state_path, {**record, "remote_path": record["upload_path"], "revision": args.revision, "status": "failed", "error_category": category, "error": error, "batch": batch_number, "uploaded_at": time.time()})
+        logger.error("batch_failed batch=%s files=%s elapsed=%.1fs category=%s error=%s", batch_number, len(operations), elapsed, category, error)
+        return 0, len(operations) + invalid_count, 0.0, None, rate_limit_count
+
+
+def upload(args, logger: logging.Logger) -> int:
+    records = load_inventory(args, logger)
+    api = HfApi()
+    logger.info(
+        "direct_source_mode enabled=1 image_staging=disabled cache_root=%s",
+        args.cache_root,
+    )
+    # The reddit branch already exists. Calling create_branch on every resume
+    # consumes the repository commit-rate budget and is unnecessary.
+    cleanup_rebuildable_batch_cache(args, logger)
+    if storage_at_hard_floor(args, logger):
+        logger.error("upload_stopped reason=hard_storage_floor_before_remote_query")
+        return 75
+    latest = load_latest_state(args)
+    remote = remote_files(api, args, logger)
+    selected = select_records(records, args, latest, remote)
+    total_bytes = sum(record["size"] for record in selected)
+    scoped_total = sum(1 for record in records if record["community"] in args.communities)
+    skipped = scoped_total - len(selected)
+    logger.info(
+        "upload_plan mode=%s revision=%s selected_files=%s skipped_remote=%s selected_gib=%.3f batch_size=%s max_batch_gib=%.3f",
+        "test" if args.test else "full",
+        args.revision,
+        len(selected),
+        skipped,
+        total_bytes / (1024**3),
+        args.batch_size,
+        args.max_batch_bytes / (1024**3),
+    )
+    batch_plan = estimate_batch_plan(
+        selected,
+        tuple(args.communities),
+        args.batch_size,
+        args.max_batch_bytes,
+    )
+    logger.info(
+        "commit_plan estimated_commits=%s by_community=%s note=one_successful_batch_equals_one_commit",
+        sum(item["batches"] for item in batch_plan.values()),
+        batch_plan,
+    )
+    logger.info(
+        "storage_policy source_images_unchanged=1 local_image_copies=0 local_archives=0"
+    )
+    if args.plan_only:
+        return 0
+    state_path = args.cache_root / "upload_state.jsonl"
+    completed = failed = rate_limits = 0
+    completed_bytes = 0
+    started = time.time()
+    batches = (
+        test_batched(selected, args.max_batch_bytes)
+        if args.test
+        else community_batched(
+            selected,
+            tuple(args.communities),
+            args.batch_size,
+            args.max_batch_bytes,
+        )
+    )
+    uploaded_before = 0
+    for batch_number, (community, batch) in enumerate(batches, 1):
+        if not storage_is_safe(args, logger):
+            logger.warning(
+                "upload_storage_pressure reason=cleanup_before_continue community=%s batch=%s success=%s failed=%s remaining=%s",
+                community, batch_number, completed, failed,
+                len(selected) - completed - failed,
+            )
+            cleanup_rebuildable_batch_cache(args, logger)
+            if not storage_is_safe(args, logger):
+                wait_for_storage_recovery(args, logger, "soft_storage_floor")
+        if storage_at_hard_floor(args, logger):
+            logger.error(
+                "upload_stopped reason=hard_storage_floor community=%s batch=%s success=%s failed=%s remaining=%s",
+                community, batch_number, completed, failed,
+                len(selected) - completed - failed,
+            )
+            return 75
+        logger.info(
+            "directory_batch_plan batch=%s community=%s files=%s bytes=%s",
+            batch_number,
+            community,
+            len(batch),
+            sum(item["size"] for item in batch),
+        )
+        ok, bad, _, commit_sha, batch_rate_limits = upload_batch(api, args, logger, batch, batch_number, state_path)
+        completed += ok
+        failed += bad
+        rate_limits += batch_rate_limits
+        if ok:
+            completed_bytes += sum(item["size"] for item in batch if Path(item["local_path"]).exists())
+        uploaded_before += ok
+        elapsed = max(time.time() - started, 0.001)
+        byte_speed = completed_bytes / elapsed
+        remaining_bytes = max(total_bytes - completed_bytes, 0)
+        eta_seconds = remaining_bytes / byte_speed if byte_speed > 0 else None
+        logger.info(
+            "upload_progress batches=%s community=%s success=%s failed=%s skipped=%s uploaded_bytes=%s remaining=%s avg_speed=%.2f_files_per_sec avg_mib_per_sec=%.2f eta_seconds=%s commit=%s",
+            batch_number,
+            community,
+            completed,
+            failed,
+            skipped,
+            completed_bytes,
+            len(selected) - completed - failed,
+            completed / elapsed,
+            byte_speed / (1024**2),
+            round(eta_seconds) if eta_seconds is not None else None,
+            commit_sha,
+        )
+    if args.test:
+        after = remote_file_sizes(api, args, logger)
+        mismatches = [
+            record["upload_path"]
+            for record in selected
+            if after.get(record["upload_path"]) != record["size"]
+        ]
+        cache_images = [
+            str(path)
+            for path in args.cache_root.rglob("*")
+            if path.is_file() and path.suffix.lower() in {".jpg", ".jpeg", ".png", ".webp", ".gif", ".bmp", ".tif", ".tiff", ".avif"}
+        ]
+        state_after = load_latest_state(args)
+        state_missing = [
+            record["upload_path"]
+            for record in selected
+            if state_after.get(record["upload_path"], {}).get("status") != "uploaded"
+        ]
+        if mismatches or cache_images or state_missing or rate_limits:
+            logger.error(
+                "test_verification_failed mismatches=%s cache_image_copies=%s state_missing=%s rate_limits=%s",
+                mismatches,
+                cache_images,
+                state_missing,
+                rate_limits,
+            )
+            return 2
+        logger.info(
+            "test_verification_complete files=%s remote_paths_and_sizes_ok=1 permissions_ok=1 local_image_copies=0 state_ok=1 rate_limits=0",
+            len(selected),
+        )
+    logger.info("upload_complete revision=%s selected=%s success=%s failed=%s skipped=%s rate_limits=%s", args.revision, len(selected), completed, failed, skipped, rate_limits)
+    return 1 if failed else 0
+
+
+def write_remote_manifest(args, logger: logging.Logger) -> int:
+    records = load_inventory(args, logger)
+    state = load_latest_state(args)
+    api = HfApi()
+    remote_sizes = remote_file_sizes(api, args, logger)
+    manifest_path = args.cache_root / "manifest_remote.jsonl"
+    temp_path = manifest_path.with_suffix(".jsonl.part")
+    counts = Counter()
+    with temp_path.open("w", encoding="utf-8") as handle:
+        for record in records:
+            remote_path = manifest_remote_path(record, remote_sizes)
+            state_record = state.get(remote_path) or state.get(record["relative_path"]) or state.get(record["legacy_relative_path"]) or {}
+            exists = remote_sizes.get(remote_path) == record["size"]
+            digest = state_record.get("sha256") or sha256_file(Path(record["local_path"]))
+            output = {
+                "community": record["community"],
+                "filename": record["filename"],
+                "remote_path": remote_path,
+                "size": record["size"],
+                "sha256": digest,
+                "remote_exists": exists,
+                "status": "uploaded" if exists else state_record.get("status", "pending"),
+                "error": state_record.get("error"),
+            }
+            counts[output["status"]] += 1
+            handle.write(json.dumps(output, ensure_ascii=False, separators=(",", ":")) + "\n")
+    temp_path.replace(manifest_path)
+    summary = {"created_at": time.time(), "records": len(records), "counts": dict(counts)}
+    (args.cache_root / "manifest_remote_summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8")
+    manifest_operations = []
+    for community in args.communities:
+        community_manifest = args.cache_root / f"image_manifest_remote_{community}.jsonl"
+        with community_manifest.open("w", encoding="utf-8") as handle:
+            for record in records:
+                if record["community"] != community:
+                    continue
+                remote_path = manifest_remote_path(record, remote_sizes)
+                state_record = state.get(remote_path) or state.get(record["relative_path"]) or state.get(record["legacy_relative_path"]) or {}
+                exists = remote_sizes.get(remote_path) == record["size"]
+                digest = state_record.get("sha256") or sha256_file(Path(record["local_path"]))
+                output = {
+                    "community": record["community"],
+                    "filename": record["filename"],
+                    "remote_path": remote_path,
+                    "size": record["size"],
+                    "sha256": digest,
+                    "remote_exists": exists,
+                    "status": "uploaded" if exists else state_record.get("status", "pending"),
+                    "error": state_record.get("error"),
+                }
+                handle.write(json.dumps(output, ensure_ascii=False, separators=(",", ":")) + "\n")
+        manifest_operations.append(
+            CommitOperationAdd(
+                path_in_repo=f"reddit/image_manifests/{community}/image_manifest_remote.jsonl",
+                path_or_fileobj=community_manifest,
+            )
+        )
+    missing = counts.get("pending", 0) + counts.get("failed", 0)
+    inventory_paths = {
+        path
+        for record in records
+        for path in (record["relative_path"], record["legacy_relative_path"])
+    }
+    remote_extra = sorted(set(remote_sizes) - inventory_paths)
+    if missing or remote_extra:
+        logger.error(
+            "manifest_remote_upload_refused missing_or_mismatched=%s remote_extra=%s",
+            missing,
+            len(remote_extra),
+        )
+        return 2
+    try:
+        info = api.create_commit(
+            repo_id=args.repo_id,
+            operations=manifest_operations,
+            commit_message="Update Reddit remote image manifests",
+            repo_type="dataset",
+            revision=args.revision,
+            num_threads=args.upload_threads,
+        )
+        logger.info("manifest_remote_uploaded commit=%s files=%s", getattr(info, "oid", None), len(manifest_operations))
+    except Exception:
+        logger.exception("manifest_remote_upload_failed")
+        raise
+    logger.info("manifest_cache_complete records=%s counts=%s path=%s", len(records), dict(counts), manifest_path)
+    return 0
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("command", choices=("inventory", "upload", "manifest"))
+    parser.add_argument("--repo-id", default=DEFAULT_REPO_ID)
+    parser.add_argument("--revision", default=DEFAULT_REVISION)
+    parser.add_argument("--source-root", type=Path, default=DEFAULT_SOURCE_ROOT)
+    parser.add_argument("--overflow-root", type=Path, default=DEFAULT_OVERFLOW_ROOT)
+    parser.add_argument("--cache-root", type=Path, default=DEFAULT_CACHE_ROOT)
+    parser.add_argument("--communities", nargs="+", choices=COMMUNITIES, default=list(COMMUNITIES))
+    parser.add_argument(
+        "--batch-size",
+        type=int,
+        default=10000,
+        help="Maximum files per community directory batch; files are also capped by --max-batch-bytes. Lower values reduce per-commit failure risk.",
+    )
+    parser.add_argument("--max-batch-bytes", type=int, default=5 * 1024 * 1024 * 1024)
+    parser.add_argument(
+        "--upload-threads",
+        type=int,
+        default=6,
+        help="Concurrent file uploads inside each large commit; default is 6.",
+    )
+    parser.add_argument("--request-timeout", type=float, default=180.0)
+    parser.add_argument("--batch-retries", type=int, default=3)
+    parser.add_argument("--retry-backoff-seconds", type=float, default=10.0)
+    parser.add_argument("--rate-limit-backoff-seconds", type=float, default=3700.0)
+    parser.add_argument("--rate-limit-poll-seconds", type=float, default=300.0)
+    parser.add_argument("--heartbeat-seconds", type=float, default=30.0)
+    parser.add_argument("--min-c-free-gib", type=float, default=5.0,
+                        help="Soft watermark: clean rebuildable cache when below this value.")
+    parser.add_argument("--min-d-free-gib", type=float, default=2.0)
+    parser.add_argument("--hard-c-floor-gib", type=float, default=1.0,
+                        help="Hard C: floor; exit only below this value.")
+    parser.add_argument("--hard-d-floor-gib", type=float, default=2.0,
+                        help="Hard D: floor; exit only below this value.")
+    parser.add_argument(
+        "--storage-recovery-buffer-gib", type=float, default=1.0,
+        help="Extra free space required before resuming after a threshold pause.",
+    )
+    parser.add_argument(
+        "--storage-check-seconds", type=float, default=60.0,
+        help="How often a paused uploader checks disk space.",
+    )
+    parser.add_argument("--test", action="store_true")
+    parser.add_argument("--test-per-community", type=int, default=3)
+    parser.add_argument("--limit", type=int)
+    parser.add_argument("--plan-only", action="store_true")
+    parser.add_argument("--rebuild-inventory", action="store_true")
+    args = parser.parse_args()
+    if min(args.batch_size, args.max_batch_bytes, args.request_timeout, args.batch_retries, args.heartbeat_seconds, args.rate_limit_poll_seconds, args.min_c_free_gib, args.min_d_free_gib, args.hard_c_floor_gib, args.hard_d_floor_gib, args.storage_recovery_buffer_gib, args.storage_check_seconds) <= 0:
+        parser.error("batch, timeout, retry, and heartbeat values must be positive")
+    if args.hard_c_floor_gib >= args.min_c_free_gib or args.hard_d_floor_gib > args.min_d_free_gib:
+        parser.error("hard storage floors must be below C soft watermark and no higher than D soft watermark")
+    configure_http_client(args.request_timeout)
+    logger = setup_logging(args.cache_root)
+    logger.info("command_start command=%s pid=%s", args.command, os.getpid())
+    if args.command == "inventory":
+        build_inventory(args, logger)
+        return 0
+    if args.command == "manifest":
+        return write_remote_manifest(args, logger)
+    release_upload_lock = acquire_upload_lock(args.cache_root, logger)
+    try:
+        return upload(args, logger)
+    finally:
+        release_upload_lock()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

reddit/_rescue_20260917/raw/scripts/upload_reddit_images_large_folder.py

@@ -0,0 +1,163 @@
+"""Resume Reddit image upload with Hugging Face's resilient large-folder uploader.
+
+The staging tree contains symbolic links only. Image bytes remain in the source
+directories on D:, while the local tree supplies the desired remote layout.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import os
+import shutil
+import sys
+from pathlib import Path
+
+from huggingface_hub import HfApi
+
+DEFAULT_REPO_ID = "Geo-Club/Geo-Video"
+DEFAULT_REVISION = "reddit"
+DEFAULT_SOURCE_ROOT = Path(r"D:\GeoAgent\Geo-CoT dataset\外网图像地理定位数据收集\reddit_posts\solved_communities")
+DEFAULT_OVERFLOW_ROOT = Path(r"C:\GeoAgent_reddit_overflow\solved_communities")
+DEFAULT_CACHE_ROOT = Path(r"C:\GeoAgent_hf_upload_cache\reddit")
+DEFAULT_VIEW_ROOT = Path(r"C:\GeoAgent_hf_upload_large_folder\reddit")
+COMMUNITIES = ("whereisthis", "GeoPuzzle", "PictureGame")
+
+
+def read_jsonl(path: Path):
+    if not path.exists():
+        return
+    with path.open("r", encoding="utf-8") as handle:
+        for line in handle:
+            if line.strip():
+                yield json.loads(line)
+
+
+def remote_sizes(api: HfApi, args, logger: logging.Logger) -> dict[str, int]:
+    entries = api.list_repo_tree(
+        args.repo_id,
+        path_in_repo="reddit/images",
+        recursive=True,
+        revision=args.revision,
+        repo_type="dataset",
+    )
+    result = {
+        entry.path: int(entry.size)
+        for entry in entries
+        if getattr(entry, "size", None) is not None
+    }
+    logger.info("remote_inventory_complete files=%s bytes=%s", len(result), sum(result.values()))
+    return result
+
+
+def setup_logging(path: Path) -> logging.Logger:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    logger = logging.getLogger("reddit_large_folder")
+    logger.setLevel(logging.INFO)
+    logger.handlers.clear()
+    handler = logging.FileHandler(path, encoding="utf-8")
+    handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(message)s"))
+    console = logging.StreamHandler(sys.stdout)
+    console.setFormatter(handler.formatter)
+    logger.addHandler(handler)
+    logger.addHandler(console)
+    return logger
+
+
+def storage_ok(args, logger: logging.Logger) -> bool:
+    c_free = shutil.disk_usage(args.view_root.anchor or "C:\\").free / (1024**3)
+    d_free = shutil.disk_usage(args.source_root.anchor or "D:\\").free / (1024**3)
+    ok = c_free >= args.min_c_free_gib and d_free >= args.min_d_free_gib
+    logger.info(
+        "storage_check c_free_gib=%.2f d_free_gib=%.2f safe=%s thresholds=%.1f/%.1f",
+        c_free, d_free, int(ok), args.min_c_free_gib, args.min_d_free_gib,
+    )
+    return ok
+
+
+def make_link_view(args, logger: logging.Logger, limit: int | None) -> int:
+    inventory = list(read_jsonl(args.cache_root / "inventory.jsonl") or ())
+    api = HfApi()
+    remote = remote_sizes(api, args, logger)
+    pending = [
+        record for record in inventory
+        if record["community"] in args.communities
+        and record["relative_path"] not in remote
+        and record["legacy_relative_path"] not in remote
+    ]
+    if limit is not None:
+        pending = pending[:limit]
+    logger.info("large_folder_view_plan pending=%s limit=%s", len(pending), limit)
+    args.view_root.mkdir(parents=True, exist_ok=True)
+    created = 0
+    for record in pending:
+        source = Path(record["local_path"])
+        target = args.view_root / record["relative_path"]
+        if not source.is_file() or source.stat().st_size != record["size"]:
+            logger.error("source_invalid path=%s", source)
+            continue
+        target.parent.mkdir(parents=True, exist_ok=True)
+        if target.exists() or target.is_symlink():
+            if target.is_symlink() and target.resolve() == source.resolve():
+                continue
+            raise RuntimeError(f"Refusing to overwrite existing view entry: {target}")
+        target.symlink_to(source, target_is_directory=False)
+        created += 1
+        if created % 1000 == 0:
+            logger.info("large_folder_view_progress links=%s", created)
+    logger.info("large_folder_view_complete links=%s bytes=%s copies=0", created, sum(r["size"] for r in pending))
+    return created
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("command", choices=("prepare", "upload"))
+    parser.add_argument("--repo-id", default=DEFAULT_REPO_ID)
+    parser.add_argument("--revision", default=DEFAULT_REVISION)
+    parser.add_argument("--source-root", type=Path, default=DEFAULT_SOURCE_ROOT)
+    parser.add_argument("--cache-root", type=Path, default=DEFAULT_CACHE_ROOT)
+    parser.add_argument("--view-root", type=Path, default=DEFAULT_VIEW_ROOT)
+    parser.add_argument("--communities", nargs="+", choices=COMMUNITIES, default=list(COMMUNITIES))
+    parser.add_argument("--workers", type=int, default=8)
+    parser.add_argument("--limit", type=int)
+    parser.add_argument("--print-report-every", type=int, default=60)
+    parser.add_argument("--min-c-free-gib", type=float, default=5.0)
+    parser.add_argument("--min-d-free-gib", type=float, default=2.0)
+    args = parser.parse_args()
+    if args.command == "upload":
+        args.cache_root.mkdir(parents=True, exist_ok=True)
+        sys.stdout = (args.cache_root / "large_folder_console.log").open(
+            "a", encoding="utf-8", buffering=1
+        )
+        sys.stderr = (args.cache_root / "large_folder_console_error.log").open(
+            "a", encoding="utf-8", buffering=1
+        )
+    logger = setup_logging(args.cache_root / "large_folder_upload.log")
+    logger.info("command_start command=%s pid=%s", args.command, os.getpid())
+    if not storage_ok(args, logger):
+        logger.error("upload_paused reason=storage_threshold")
+        return 75
+    if args.command == "prepare":
+        make_link_view(args, logger, args.limit)
+        return 0
+    if not args.view_root.exists():
+        raise RuntimeError("View directory is missing; run prepare first")
+    if args.limit is not None:
+        raise ValueError("--limit is only supported by prepare")
+    logger.info("large_folder_upload_start view_root=%s workers=%s copies=0", args.view_root, args.workers)
+    HfApi().upload_large_folder(
+        repo_id=args.repo_id,
+        folder_path=args.view_root,
+        repo_type="dataset",
+        revision=args.revision,
+        num_workers=args.workers,
+        print_report=True,
+        print_report_every=args.print_report_every,
+    )
+    logger.info("large_folder_upload_complete revision=%s", args.revision)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

reddit/_rescue_20260917/raw/scripts/validate_canonical_reddit_metadata.py

@@ -0,0 +1,233 @@
+"""Create and validate the final canonical Reddit image manifest.
+
+This is a local, non-destructive gate. It neither uploads nor deletes files.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import time
+from collections import Counter, defaultdict
+from pathlib import Path
+
+
+IMAGE_RE = re.compile(
+    rb"reddit/images/(?:whereisthis|GeoPuzzle|PictureGame)/(?:canonical/)?(?:[0-9]{4}/)?"
+    rb"[A-Za-z0-9._-]+\.(?:jpeg|jpg|png|webp|gif|bmp|tiff|tif|avif)(?![A-Za-z0-9.])",
+    re.IGNORECASE,
+)
+
+
+def jsonl(path: Path):
+    with path.open("r", encoding="utf-8") as handle:
+        for number, line in enumerate(handle, 1):
+            if line.strip():
+                try:
+                    yield json.loads(line)
+                except json.JSONDecodeError as exc:
+                    raise ValueError(f"invalid JSON: {path}:{number}") from exc
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--inventory", type=Path, required=True)
+    parser.add_argument("--naming-root", type=Path, required=True)
+    parser.add_argument("--dedup-root", type=Path, required=True)
+    parser.add_argument("--association-root", type=Path, required=True)
+    parser.add_argument("--bundle-root", type=Path, required=True)
+    args = parser.parse_args()
+    started = time.time()
+    reddit_root = args.bundle_root / "reddit"
+    manifest_root = reddit_root / "image_manifests"
+    report_root = reddit_root / "reports"
+    manifest_root.mkdir(parents=True, exist_ok=True)
+    report_root.mkdir(parents=True, exist_ok=True)
+
+    inventory = {(x["community"], x["filename"]): x for x in jsonl(args.inventory)}
+    associations = {(x["community"], x["filename"]): x for x in jsonl(args.association_root / "association_recovery.jsonl")}
+    naming = {}
+    old_path_to_key = {}
+    for x in jsonl(args.naming_root / "canonical_image_mapping.jsonl"):
+        key = (x["community"], x["old_filename"])
+        naming[key] = x
+        old_path_to_key[x["old_remote_path"]] = key
+
+    dedup = {x["original_path"]: x["canonical_path"] for x in jsonl(args.dedup_root / "content_dedup_mapping.jsonl")}
+    placeholder_groups = json.loads((args.dedup_root / "placeholder_candidates.json").read_text(encoding="utf-8"))
+    placeholder_hashes = {
+        x["sha256"] for x in placeholder_groups
+        if x.get("count") in {59, 3229} or all(int(m.get("size", 0)) in {114, 503} for m in x.get("members", []))
+    }
+
+    errors = []
+    rows = []
+    deletion_candidates = []
+    placeholder_deletion_candidates = []
+    sha_targets = defaultdict(set)
+    community_stats = defaultdict(Counter)
+    target_paths = set()
+    placeholder_files = 0
+    for key, inv in sorted(inventory.items()):
+        name = naming.get(key)
+        assoc = associations.get(key)
+        if not name:
+            errors.append({"type": "missing_naming", "key": key})
+            continue
+        if not assoc or not assoc.get("references"):
+            errors.append({"type": "missing_association", "key": key})
+        old_path = name["old_remote_path"]
+        sha = name["sha256"]
+        is_placeholder = sha in placeholder_hashes
+        canonical_old = None if is_placeholder else dedup.get(old_path, old_path)
+        canonical_key = old_path_to_key.get(canonical_old) if canonical_old else None
+        canonical_name = naming.get(canonical_key) if canonical_key else None
+        if not is_placeholder and not canonical_name:
+            errors.append({"type": "missing_canonical_target", "old_path": old_path, "canonical_old": canonical_old})
+            continue
+        target = None if is_placeholder else canonical_name["new_remote_path"]
+        status = "invalid_placeholder_image" if is_placeholder else "valid"
+        is_canonical = False if is_placeholder else old_path == canonical_old
+        local = Path(name["local_path"])
+        source_ok = local.is_file() and local.stat().st_size == int(name["size"])
+        if not source_ok:
+            errors.append({"type": "source_missing_or_size_changed", "old_path": old_path, "local_path": str(local)})
+        row = {
+            "community": key[0],
+            "filename": key[1],
+            "original_path": old_path,
+            "canonical_path": target,
+            "size": int(name["size"]),
+            "sha256": sha,
+            "post_ids": (assoc or {}).get("post_ids", []),
+            "references": (assoc or {}).get("references", []),
+            "association_count": (assoc or {}).get("association_count", 0),
+            "status": status,
+            "is_canonical": is_canonical,
+            "source_exists_and_size_matches": source_ok,
+            "remote_exists": False,
+            "delete_allowed": False,
+        }
+        rows.append(row)
+        if target:
+            target_paths.add(target)
+            sha_targets[sha].add(target)
+        community_stats[key[0]]["files"] += 1
+        community_stats[key[0]]["bytes"] += int(name["size"])
+        community_stats[key[0]][status] += 1
+        if is_placeholder:
+            placeholder_files += 1
+            placeholder_deletion_candidates.append({
+                "original_path": old_path,
+                "canonical_path": None,
+                "sha256": sha,
+                "reason": "invalid_placeholder_image",
+                "delete_allowed": False,
+                "blocked_by": "text_reference_commit_and_remote_verification_pending",
+            })
+        elif not is_canonical:
+            deletion_candidates.append({
+                "original_path": old_path,
+                "canonical_path": target,
+                "sha256": sha,
+                "reason": "valid_duplicate_content",
+                "delete_allowed": False,
+                "blocked_by": "canonical_remote_upload_and_reference_verification_pending",
+            })
+
+    invalid_sha_target_counts = []
+    for sha, targets in sha_targets.items():
+        expected = placeholder_files and sha in placeholder_hashes
+        if not expected and len(targets) != 1:
+            invalid_sha_target_counts.append({"sha256": sha, "target_count": len(targets)})
+    if invalid_sha_target_counts:
+        errors.extend({"type": "valid_sha_has_multiple_targets", **x} for x in invalid_sha_target_counts)
+
+    manifest_path = manifest_root / "canonical_image_manifest.jsonl"
+    with manifest_path.open("w", encoding="utf-8", newline="\n") as handle:
+        for row in rows:
+            handle.write(json.dumps(row, ensure_ascii=False, separators=(",", ":")) + "\n")
+    candidate_path = manifest_root / "remote_deletion_candidates_pending.jsonl"
+    with candidate_path.open("w", encoding="utf-8", newline="\n") as handle:
+        for row in deletion_candidates:
+            handle.write(json.dumps(row, ensure_ascii=False, separators=(",", ":")) + "\n")
+    placeholder_candidate_path = manifest_root / "invalid_placeholder_remote_candidates_pending.jsonl"
+    with placeholder_candidate_path.open("w", encoding="utf-8", newline="\n") as handle:
+        for row in placeholder_deletion_candidates:
+            handle.write(json.dumps(row, ensure_ascii=False, separators=(",", ":")) + "\n")
+
+    reference_count = 0
+    unresolved = Counter()
+    placeholder_references = 0
+    files_scanned = 0
+    bytes_scanned = 0
+    for root_name in ("posts_tagged", "manual_review", "image_manifests"):
+        root = reddit_root / root_name
+        for path in sorted(root.rglob("*.jsonl")):
+            if path in {manifest_path, candidate_path, placeholder_candidate_path} or path.name == "canonical_path_mapping.jsonl":
+                continue
+            files_scanned += 1
+            with path.open("rb") as handle:
+                for line in handle:
+                    bytes_scanned += len(line)
+                    for raw in IMAGE_RE.findall(line):
+                        value = raw.decode("utf-8", errors="replace")
+                        reference_count += 1
+                        if value not in target_paths:
+                            unresolved[value] += 1
+    if unresolved:
+        errors.append({"type": "unresolved_output_references", "paths": len(unresolved), "occurrences": sum(unresolved.values())})
+
+    for row in rows:
+        if row["status"] == "invalid_placeholder_image":
+            placeholder_references += row["association_count"]
+
+    checks = {
+        "inventory_equals_manifest": len(inventory) == len(rows) == 225307,
+        "all_images_associated": len(associations) == len(inventory) and all(x["association_count"] > 0 for x in rows),
+        "all_sources_exist_and_size_match": all(x["source_exists_and_size_matches"] for x in rows),
+        "valid_sha_single_target": not invalid_sha_target_counts,
+        "placeholder_hash_count_is_two": len(placeholder_hashes) == 2,
+        "placeholder_files_excluded_from_targets": all(
+            r["canonical_path"] is None and not r["is_canonical"]
+            for r in rows if r["sha256"] in placeholder_hashes
+        ),
+        "placeholder_references_removed": all(
+            path not in unresolved for path in (r["original_path"] for r in rows if r["sha256"] in placeholder_hashes)
+        ),
+        "all_output_references_resolve_locally": not unresolved,
+        "remote_unchanged": True,
+        "deletion_is_blocked_until_remote_verification": True,
+    }
+    report = {
+        "status": "passed_local_gate_remote_pending" if all(checks.values()) else "failed_local_gate",
+        "created_at": time.time(),
+        "elapsed_seconds": round(time.time() - started, 2),
+        "checks": checks,
+        "inventory_records": len(inventory),
+        "manifest_records": len(rows),
+        "unique_canonical_targets": len(target_paths),
+        "valid_duplicate_deletion_candidates": len(deletion_candidates),
+        "placeholder_files": placeholder_files,
+        "placeholder_remote_deletion_candidates": len(placeholder_deletion_candidates),
+        "placeholder_reference_associations": placeholder_references,
+        "output_reference_occurrences": reference_count,
+        "unresolved_output_paths": len(unresolved),
+        "files_scanned": files_scanned,
+        "bytes_scanned": bytes_scanned,
+        "community_stats": {k: dict(v) for k, v in community_stats.items()},
+        "error_count": len(errors),
+        "remote_modified": False,
+        "delete_allowed": False,
+        "next_gate": "upload canonical targets to backup/test revision and verify remote size/hash before reference commit or deletion",
+    }
+    (report_root / "canonical_validation_report.json").write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding="utf-8")
+    (report_root / "canonical_validation_errors.json").write_text(json.dumps(errors, ensure_ascii=False, indent=2), encoding="utf-8")
+    (report_root / "unresolved_output_references.json").write_text(json.dumps(unresolved, ensure_ascii=False, indent=2), encoding="utf-8")
+    print(json.dumps(report, ensure_ascii=False), flush=True)
+    return 0 if report["status"] == "passed_local_gate_remote_pending" else 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

reddit/_rescue_20260917/raw/solved_whereisthis/download.log

@@ -0,0 +1,297 @@
+2026-09-01 18:47:08,601 INFO prepared posts=9873 comments=78032/201544 unique_images=20674
+2026-09-01 18:47:12,209 INFO progress=1/20674 downloaded=1 failed=0 speed=0.04 images/s
+2026-09-01 18:47:16,820 INFO progress=25/20674 downloaded=25 failed=0 speed=0.88 images/s
+2026-09-01 18:47:22,320 INFO progress=50/20674 downloaded=45 failed=5 speed=1.47 images/s
+2026-09-01 18:47:28,164 INFO progress=75/20674 downloaded=67 failed=8 speed=1.88 images/s
+2026-09-01 18:47:32,798 INFO progress=100/20674 downloaded=92 failed=8 speed=2.25 images/s
+2026-09-01 18:47:36,753 INFO progress=125/20674 downloaded=115 failed=10 speed=2.58 images/s
+2026-09-01 18:47:40,104 INFO progress=150/20674 downloaded=139 failed=11 speed=2.90 images/s
+2026-09-01 18:47:43,963 INFO progress=175/20674 downloaded=164 failed=11 speed=3.15 images/s
+2026-09-01 18:47:47,627 INFO progress=200/20674 downloaded=188 failed=12 speed=3.38 images/s
+2026-09-01 18:47:51,105 INFO progress=225/20674 downloaded=212 failed=13 speed=3.59 images/s
+2026-09-01 18:47:54,637 INFO progress=250/20674 downloaded=237 failed=13 speed=3.77 images/s
+2026-09-01 18:47:57,786 INFO progress=275/20674 downloaded=262 failed=13 speed=3.96 images/s
+2026-09-01 18:48:01,238 INFO progress=300/20674 downloaded=287 failed=13 speed=4.12 images/s
+2026-09-01 18:48:05,027 INFO progress=325/20674 downloaded=312 failed=13 speed=4.24 images/s
+2026-09-01 18:48:08,815 INFO progress=350/20674 downloaded=337 failed=13 speed=4.35 images/s
+2026-09-01 18:48:12,538 INFO progress=375/20674 downloaded=361 failed=14 speed=4.46 images/s
+2026-09-01 18:48:16,260 INFO progress=400/20674 downloaded=386 failed=14 speed=4.55 images/s
+2026-09-01 18:48:19,336 INFO progress=425/20674 downloaded=410 failed=15 speed=4.67 images/s
+2026-09-01 18:48:22,961 INFO progress=450/20674 downloaded=435 failed=15 speed=4.76 images/s
+2026-09-01 18:48:26,537 INFO progress=475/20674 downloaded=459 failed=16 speed=4.84 images/s
+2026-09-01 18:48:29,932 INFO progress=500/20674 downloaded=484 failed=16 speed=4.92 images/s
+2026-09-01 18:48:33,319 INFO progress=525/20674 downloaded=509 failed=16 speed=5.00 images/s
+2026-09-01 18:48:36,918 INFO progress=550/20674 downloaded=534 failed=16 speed=5.07 images/s
+2026-09-01 18:48:40,020 INFO progress=575/20674 downloaded=559 failed=16 speed=5.15 images/s
+2026-09-01 18:48:43,689 INFO progress=600/20674 downloaded=582 failed=18 speed=5.20 images/s
+2026-09-01 18:48:47,981 INFO progress=625/20674 downloaded=606 failed=19 speed=5.23 images/s
+2026-09-01 18:48:51,187 INFO progress=650/20674 downloaded=631 failed=19 speed=5.29 images/s
+2026-09-01 18:48:54,741 INFO progress=675/20674 downloaded=656 failed=19 speed=5.34 images/s
+2026-09-01 18:48:58,495 INFO progress=700/20674 downloaded=681 failed=19 speed=5.38 images/s
+2026-09-01 18:49:04,127 INFO progress=725/20674 downloaded=705 failed=20 speed=5.34 images/s
+2026-09-01 18:49:08,619 INFO progress=750/20674 downloaded=727 failed=23 speed=5.35 images/s
+2026-09-01 18:49:13,439 INFO progress=775/20674 downloaded=751 failed=24 speed=5.34 images/s
+2026-09-01 18:49:17,164 INFO progress=800/20674 downloaded=776 failed=24 speed=5.38 images/s
+2026-09-01 18:49:21,030 INFO progress=825/20674 downloaded=801 failed=24 speed=5.40 images/s
+2026-09-01 18:49:24,615 INFO progress=850/20674 downloaded=825 failed=25 speed=5.44 images/s
+2026-09-01 18:49:28,374 INFO progress=875/20674 downloaded=849 failed=26 speed=5.47 images/s
+2026-09-01 18:49:32,044 INFO progress=900/20674 downloaded=873 failed=27 speed=5.50 images/s
+2026-09-01 18:49:35,684 INFO progress=925/20674 downloaded=897 failed=28 speed=5.53 images/s
+2026-09-01 18:49:39,332 INFO progress=950/20674 downloaded=921 failed=29 speed=5.56 images/s
+2026-09-01 18:49:43,570 INFO progress=975/20674 downloaded=946 failed=29 speed=5.57 images/s
+2026-09-01 18:49:46,632 INFO progress=1000/20674 downloaded=969 failed=31 speed=5.61 images/s
+2026-09-01 18:49:50,136 INFO progress=1025/20674 downloaded=994 failed=31 speed=5.64 images/s
+2026-09-01 18:49:53,682 INFO progress=1050/20674 downloaded=1019 failed=31 speed=5.67 images/s
+2026-09-01 18:49:57,542 INFO progress=1075/20674 downloaded=1044 failed=31 speed=5.68 images/s
+2026-09-01 18:50:00,779 INFO progress=1100/20674 downloaded=1068 failed=32 speed=5.72 images/s
+2026-09-01 18:50:04,336 INFO progress=1125/20674 downloaded=1093 failed=32 speed=5.74 images/s
+2026-09-01 18:50:07,169 INFO progress=1150/20674 downloaded=1118 failed=32 speed=5.78 images/s
+2026-09-01 18:50:10,344 INFO progress=1175/20674 downloaded=1143 failed=32 speed=5.82 images/s
+2026-09-01 18:50:13,192 INFO progress=1200/20674 downloaded=1168 failed=32 speed=5.86 images/s
+2026-09-01 19:06:06,763 INFO prepared posts=9873 comments=78032/201544 unique_images=20674
+2026-09-01 19:06:09,073 INFO progress=1/20674 downloaded=1 failed=0 speed=0.05 images/s
+2026-09-01 19:06:10,135 INFO progress=25/20674 downloaded=25 failed=0 speed=1.14 images/s
+2026-09-01 19:06:10,710 INFO progress=50/20674 downloaded=48 failed=2 speed=2.22 images/s
+2026-09-01 19:06:11,193 INFO progress=75/20674 downloaded=71 failed=4 speed=3.26 images/s
+2026-09-01 19:06:11,392 INFO progress=100/20674 downloaded=96 failed=4 speed=4.31 images/s
+2026-09-01 19:06:11,847 INFO progress=125/20674 downloaded=120 failed=5 speed=5.29 images/s
+2026-09-01 19:06:12,219 INFO progress=150/20674 downloaded=145 failed=5 speed=6.25 images/s
+2026-09-01 19:06:12,477 INFO progress=175/20674 downloaded=170 failed=5 speed=7.21 images/s
+2026-09-01 19:06:12,921 INFO progress=200/20674 downloaded=195 failed=5 speed=8.09 images/s
+2026-09-01 19:06:13,944 INFO progress=225/20674 downloaded=219 failed=6 speed=8.74 images/s
+2026-09-01 19:06:14,285 INFO progress=250/20674 downloaded=244 failed=6 speed=9.59 images/s
+2026-09-01 19:06:14,566 INFO progress=275/20674 downloaded=269 failed=6 speed=10.43 images/s
+2026-09-01 19:06:14,973 INFO progress=300/20674 downloaded=293 failed=7 speed=11.21 images/s
+2026-09-01 19:06:15,293 INFO progress=325/20674 downloaded=318 failed=7 speed=12.00 images/s
+2026-09-01 19:06:15,661 INFO progress=350/20674 downloaded=342 failed=8 speed=12.75 images/s
+2026-09-01 19:06:16,129 INFO progress=375/20674 downloaded=365 failed=10 speed=13.43 images/s
+2026-09-01 19:06:16,525 INFO progress=400/20674 downloaded=389 failed=11 speed=14.12 images/s
+2026-09-01 19:06:17,574 INFO progress=425/20674 downloaded=412 failed=13 speed=14.47 images/s
+2026-09-01 19:06:18,681 INFO progress=450/20674 downloaded=436 failed=14 speed=14.76 images/s
+2026-09-01 19:06:19,794 INFO progress=475/20674 downloaded=461 failed=14 speed=15.04 images/s
+2026-09-01 19:06:20,636 INFO progress=500/20674 downloaded=485 failed=15 speed=15.42 images/s
+2026-09-01 19:06:21,564 INFO progress=525/20674 downloaded=510 failed=15 speed=15.74 images/s
+2026-09-01 19:06:22,597 INFO progress=550/20674 downloaded=534 failed=16 speed=15.99 images/s
+2026-09-01 19:06:23,635 INFO progress=575/20674 downloaded=559 failed=16 speed=16.23 images/s
+2026-09-01 19:06:24,640 INFO progress=600/20674 downloaded=583 failed=17 speed=16.47 images/s
+2026-09-01 19:06:25,657 INFO progress=625/20674 downloaded=607 failed=18 speed=16.69 images/s
+2026-09-01 19:06:26,698 INFO progress=650/20674 downloaded=632 failed=18 speed=16.89 images/s
+2026-09-01 19:06:27,731 INFO progress=675/20674 downloaded=657 failed=18 speed=17.08 images/s
+2026-09-01 19:06:28,742 INFO progress=700/20674 downloaded=682 failed=18 speed=17.27 images/s
+2026-09-01 19:06:29,841 INFO progress=725/20674 downloaded=706 failed=19 speed=17.41 images/s
+2026-09-01 19:06:30,303 INFO progress=750/20674 downloaded=731 failed=19 speed=17.81 images/s
+2026-09-01 19:06:30,741 INFO progress=775/20674 downloaded=756 failed=19 speed=18.22 images/s
+2026-09-01 19:06:31,211 INFO progress=800/20674 downloaded=780 failed=20 speed=18.60 images/s
+2026-09-01 19:06:31,653 INFO progress=825/20674 downloaded=805 failed=20 speed=18.99 images/s
+2026-09-01 19:06:32,246 INFO progress=850/20674 downloaded=830 failed=20 speed=19.30 images/s
+2026-09-01 19:06:32,510 INFO progress=875/20674 downloaded=855 failed=20 speed=19.75 images/s
+2026-09-01 19:06:33,043 INFO progress=900/20674 downloaded=879 failed=21 speed=20.07 images/s
+2026-09-01 19:06:33,715 INFO progress=925/20674 downloaded=902 failed=23 speed=20.32 images/s
+2026-09-01 19:06:34,209 INFO progress=950/20674 downloaded=926 failed=24 speed=20.65 images/s
+2026-09-01 19:06:34,501 INFO progress=975/20674 downloaded=950 failed=25 speed=21.06 images/s
+2026-09-01 19:06:35,066 INFO progress=1000/20674 downloaded=974 failed=26 speed=21.34 images/s
+2026-09-01 19:06:35,423 INFO progress=1025/20674 downloaded=998 failed=27 speed=21.71 images/s
+2026-09-01 19:06:36,128 INFO progress=1050/20674 downloaded=1021 failed=29 speed=21.91 images/s
+2026-09-01 19:06:36,707 INFO progress=1075/20674 downloaded=1046 failed=29 speed=22.16 images/s
+2026-09-01 19:06:37,346 INFO progress=1100/20674 downloaded=1071 failed=29 speed=22.38 images/s
+2026-09-01 19:06:38,208 INFO progress=1125/20674 downloaded=1095 failed=30 speed=22.50 images/s
+2026-09-01 19:06:39,232 INFO progress=1150/20674 downloaded=1119 failed=31 speed=22.54 images/s
+2026-09-01 19:06:40,245 INFO progress=1175/20674 downloaded=1144 failed=31 speed=22.58 images/s
+2026-09-01 19:06:41,286 INFO progress=1200/20674 downloaded=1169 failed=31 speed=22.61 images/s
+2026-09-01 19:12:29,111 INFO prepared posts=9873 comments=78032/201544 unique_images=11239
+2026-09-01 19:12:30,429 INFO progress=1/11239 downloaded=1 failed=0 speed=0.05 images/s
+2026-09-01 19:12:31,819 INFO progress=25/11239 downloaded=21 failed=4 speed=1.12 images/s
+2026-09-01 19:12:32,695 INFO progress=50/11239 downloaded=44 failed=6 speed=2.16 images/s
+2026-09-01 19:12:36,164 INFO progress=75/11239 downloaded=63 failed=12 speed=2.81 images/s
+2026-09-01 19:12:37,388 INFO progress=100/11239 downloaded=83 failed=17 speed=3.59 images/s
+2026-09-01 19:12:38,027 INFO progress=125/11239 downloaded=107 failed=18 speed=4.38 images/s
+2026-09-01 19:12:39,347 INFO progress=150/11239 downloaded=129 failed=21 speed=5.03 images/s
+2026-09-01 19:12:41,206 INFO progress=175/11239 downloaded=151 failed=24 speed=5.52 images/s
+2026-09-01 19:12:41,479 INFO progress=200/11239 downloaded=174 failed=26 speed=6.26 images/s
+2026-09-01 19:12:41,990 INFO progress=225/11239 downloaded=198 failed=27 speed=6.93 images/s
+2026-09-01 19:12:42,376 INFO progress=250/11239 downloaded=221 failed=29 speed=7.61 images/s
+2026-09-01 19:12:43,276 INFO progress=275/11239 downloaded=246 failed=29 speed=8.15 images/s
+2026-09-01 19:15:37,950 INFO prepared posts=9873 comments=78032/201544 unique_images=9958
+2026-09-01 19:15:39,190 INFO progress=1/9958 downloaded=1 failed=0 speed=0.05 images/s
+2026-09-01 19:15:40,219 INFO progress=25/9958 downloaded=25 failed=0 speed=1.19 images/s
+2026-09-01 19:15:41,199 INFO progress=50/9958 downloaded=50 failed=0 speed=2.27 images/s
+2026-09-01 19:15:41,730 INFO progress=75/9958 downloaded=75 failed=0 speed=3.33 images/s
+2026-09-01 19:15:42,343 INFO progress=100/9958 downloaded=99 failed=1 speed=4.32 images/s
+2026-09-01 19:15:43,202 INFO progress=125/9958 downloaded=124 failed=1 speed=5.20 images/s
+2026-09-01 19:15:43,899 INFO progress=150/9958 downloaded=149 failed=1 speed=6.07 images/s
+2026-09-01 19:15:44,624 INFO progress=175/9958 downloaded=174 failed=1 speed=6.88 images/s
+2026-09-01 19:15:45,330 INFO progress=200/9958 downloaded=199 failed=1 speed=7.65 images/s
+2026-09-01 19:15:46,327 INFO progress=225/9958 downloaded=222 failed=3 speed=8.29 images/s
+2026-09-01 19:18:06,221 INFO prepared posts=9873 comments=78032/201544 unique_images=7830
+2026-09-01 19:18:07,530 INFO progress=1/7830 downloaded=1 failed=0 speed=0.05 images/s
+2026-09-01 19:18:08,744 INFO progress=25/7830 downloaded=24 failed=1 speed=1.22 images/s
+2026-09-01 19:18:10,060 INFO progress=50/7830 downloaded=49 failed=1 speed=2.29 images/s
+2026-09-01 19:18:11,298 INFO progress=75/7830 downloaded=73 failed=2 speed=3.25 images/s
+2026-09-01 19:18:12,577 INFO progress=100/7830 downloaded=98 failed=2 speed=4.10 images/s
+2026-09-01 19:18:13,928 INFO progress=125/7830 downloaded=123 failed=2 speed=4.86 images/s
+2026-09-01 19:18:15,241 INFO progress=150/7830 downloaded=146 failed=4 speed=5.55 images/s
+2026-09-01 19:18:16,514 INFO progress=175/7830 downloaded=170 failed=5 speed=6.18 images/s
+2026-09-01 19:18:17,928 INFO progress=200/7830 downloaded=195 failed=5 speed=6.73 images/s
+2026-09-01 19:18:19,349 INFO progress=225/7830 downloaded=218 failed=7 speed=7.22 images/s
+2026-09-01 19:18:20,669 INFO progress=250/7830 downloaded=242 failed=8 speed=7.70 images/s
+2026-09-01 19:18:22,157 INFO progress=275/7830 downloaded=266 failed=9 speed=8.10 images/s
+2026-09-01 19:18:23,460 INFO progress=300/7830 downloaded=290 failed=10 speed=8.51 images/s
+2026-09-01 19:18:24,907 INFO progress=325/7830 downloaded=315 failed=10 speed=8.85 images/s
+2026-09-01 19:18:26,237 INFO progress=350/7830 downloaded=340 failed=10 speed=9.20 images/s
+2026-09-01 19:18:27,506 INFO progress=375/7830 downloaded=365 failed=10 speed=9.54 images/s
+2026-09-01 19:18:28,790 INFO progress=400/7830 downloaded=389 failed=11 speed=9.85 images/s
+2026-09-01 19:18:30,096 INFO progress=425/7830 downloaded=413 failed=12 speed=10.14 images/s
+2026-09-01 19:18:31,293 INFO progress=450/7830 downloaded=428 failed=22 speed=10.44 images/s
+2026-09-01 19:18:32,613 INFO progress=475/7830 downloaded=449 failed=26 speed=10.69 images/s
+2026-09-01 19:18:33,808 INFO progress=500/7830 downloaded=467 failed=33 speed=10.96 images/s
+2026-09-01 19:18:35,196 INFO progress=525/7830 downloaded=488 failed=37 speed=11.17 images/s
+2026-09-01 19:18:36,495 INFO progress=550/7830 downloaded=510 failed=40 speed=11.39 images/s
+2026-09-01 19:18:37,780 INFO progress=575/7830 downloaded=529 failed=46 speed=11.60 images/s
+2026-09-01 19:18:38,732 INFO progress=600/7830 downloaded=547 failed=53 speed=11.87 images/s
+2026-09-01 19:18:39,965 INFO progress=625/7830 downloaded=566 failed=59 speed=12.07 images/s
+2026-09-01 19:18:41,139 INFO progress=650/7830 downloaded=588 failed=62 speed=12.28 images/s
+2026-09-01 19:18:42,388 INFO progress=675/7830 downloaded=610 failed=65 speed=12.45 images/s
+2026-09-01 19:18:43,620 INFO progress=700/7830 downloaded=629 failed=71 speed=12.63 images/s
+2026-09-01 19:18:44,921 INFO progress=725/7830 downloaded=649 failed=76 speed=12.78 images/s
+2026-09-01 19:18:46,185 INFO progress=750/7830 downloaded=667 failed=83 speed=12.93 images/s
+2026-09-01 19:18:47,371 INFO progress=775/7830 downloaded=687 failed=88 speed=13.10 images/s
+2026-09-01 19:18:48,607 INFO progress=800/7830 downloaded=707 failed=93 speed=13.24 images/s
+2026-09-01 19:21:33,385 INFO prepared posts=9873 comments=78032/201544 unique_images=5397
+2026-09-01 19:21:34,745 INFO progress=1/5397 downloaded=1 failed=0 speed=0.05 images/s
+2026-09-01 19:21:36,100 INFO progress=25/5397 downloaded=24 failed=1 speed=1.15 images/s
+2026-09-01 19:21:37,421 INFO progress=50/5397 downloaded=49 failed=1 speed=2.17 images/s
+2026-09-01 19:21:38,867 INFO progress=75/5397 downloaded=73 failed=2 speed=3.06 images/s
+2026-09-01 19:21:40,266 INFO progress=100/5397 downloaded=98 failed=2 speed=3.86 images/s
+2026-09-01 19:21:41,615 INFO progress=125/5397 downloaded=123 failed=2 speed=4.58 images/s
+2026-09-01 19:21:43,058 INFO progress=150/5397 downloaded=146 failed=4 speed=5.22 images/s
+2026-09-01 19:21:44,366 INFO progress=175/5397 downloaded=170 failed=5 speed=5.83 images/s
+2026-09-01 19:21:45,770 INFO progress=200/5397 downloaded=195 failed=5 speed=6.36 images/s
+2026-09-01 19:21:47,343 INFO progress=225/5397 downloaded=218 failed=7 speed=6.82 images/s
+2026-09-01 19:21:48,631 INFO progress=250/5397 downloaded=242 failed=8 speed=7.29 images/s
+2026-09-01 19:21:49,990 INFO progress=275/5397 downloaded=267 failed=8 speed=7.71 images/s
+2026-09-01 19:21:51,269 INFO progress=300/5397 downloaded=290 failed=10 speed=8.12 images/s
+2026-09-01 19:21:52,544 INFO progress=325/5397 downloaded=315 failed=10 speed=8.51 images/s
+2026-09-01 19:21:53,947 INFO progress=350/5397 downloaded=340 failed=10 speed=8.84 images/s
+2026-09-01 19:21:55,275 INFO progress=375/5397 downloaded=365 failed=10 speed=9.16 images/s
+2026-09-01 19:21:56,572 INFO progress=400/5397 downloaded=389 failed=11 speed=9.47 images/s
+2026-09-01 19:21:58,088 INFO progress=425/5397 downloaded=411 failed=14 speed=9.71 images/s
+2026-09-01 19:21:59,306 INFO progress=450/5397 downloaded=428 failed=22 speed=10.01 images/s
+2026-09-01 19:22:00,662 INFO progress=475/5397 downloaded=449 failed=26 speed=10.25 images/s
+2026-09-01 19:22:02,008 INFO progress=500/5397 downloaded=467 failed=33 speed=10.49 images/s
+2026-09-01 19:22:03,261 INFO progress=525/5397 downloaded=488 failed=37 speed=10.73 images/s
+2026-09-01 19:22:04,585 INFO progress=550/5397 downloaded=509 failed=41 speed=10.94 images/s
+2026-09-01 19:22:05,947 INFO progress=575/5397 downloaded=529 failed=46 speed=11.14 images/s
+2026-09-01 19:22:07,282 INFO progress=600/5397 downloaded=547 failed=53 speed=11.33 images/s
+2026-09-01 19:22:08,545 INFO progress=625/5397 downloaded=566 failed=59 speed=11.53 images/s
+2026-09-01 19:22:10,005 INFO progress=650/5397 downloaded=588 failed=62 speed=11.68 images/s
+2026-09-01 19:22:11,296 INFO progress=675/5397 downloaded=609 failed=66 speed=11.85 images/s
+2026-09-01 19:22:12,397 INFO progress=700/5397 downloaded=629 failed=71 speed=12.06 images/s
+2026-09-01 19:22:14,018 INFO progress=725/5397 downloaded=649 failed=76 speed=12.15 images/s
+2026-09-01 19:22:15,334 INFO progress=750/5397 downloaded=667 failed=83 speed=12.29 images/s
+2026-09-01 19:22:16,528 INFO progress=775/5397 downloaded=687 failed=88 speed=12.46 images/s
+2026-09-01 19:22:17,937 INFO progress=800/5397 downloaded=706 failed=94 speed=12.58 images/s
+2026-09-01 19:28:09,629 INFO prepared posts=9873 comments=78032/201544 unique_images=5397
+2026-09-01 19:28:10,859 INFO progress=1/5397 downloaded=1 failed=0 speed=0.05 images/s
+2026-09-01 19:28:12,362 INFO progress=25/5397 downloaded=24 failed=1 speed=1.19 images/s
+2026-09-01 19:28:14,068 INFO progress=50/5397 downloaded=49 failed=1 speed=2.20 images/s
+2026-09-01 19:28:15,544 INFO progress=75/5397 downloaded=73 failed=2 speed=3.10 images/s
+2026-09-01 19:28:17,154 INFO progress=100/5397 downloaded=98 failed=2 speed=3.87 images/s
+2026-09-01 19:28:18,659 INFO progress=125/5397 downloaded=123 failed=2 speed=4.58 images/s
+2026-09-01 19:28:20,256 INFO progress=150/5397 downloaded=146 failed=4 speed=5.19 images/s
+2026-09-01 19:28:21,985 INFO progress=175/5397 downloaded=170 failed=5 speed=5.71 images/s
+2026-09-01 19:28:23,476 INFO progress=200/5397 downloaded=195 failed=5 speed=6.22 images/s
+2026-09-01 19:28:25,111 INFO progress=225/5397 downloaded=218 failed=7 speed=6.66 images/s
+2026-09-01 19:28:26,669 INFO progress=250/5397 downloaded=242 failed=8 speed=7.08 images/s
+2026-09-01 19:28:28,266 INFO progress=275/5397 downloaded=266 failed=9 speed=7.45 images/s
+2026-09-01 19:28:29,964 INFO progress=300/5397 downloaded=290 failed=10 speed=7.77 images/s
+2026-09-01 19:28:31,712 INFO progress=325/5397 downloaded=315 failed=10 speed=8.05 images/s
+2026-09-01 19:28:33,338 INFO progress=350/5397 downloaded=340 failed=10 speed=8.33 images/s
+2026-09-01 19:28:35,124 INFO progress=375/5397 downloaded=365 failed=10 speed=8.56 images/s
+2026-09-01 19:28:36,804 INFO progress=400/5397 downloaded=389 failed=11 speed=8.80 images/s
+2026-09-01 19:28:38,505 INFO progress=425/5397 downloaded=412 failed=13 speed=9.01 images/s
+2026-09-01 19:28:40,087 INFO progress=450/5397 downloaded=428 failed=22 speed=9.23 images/s
+2026-09-01 19:28:41,756 INFO progress=475/5397 downloaded=449 failed=26 speed=9.42 images/s
+2026-09-01 19:28:43,304 INFO progress=500/5397 downloaded=467 failed=33 speed=9.62 images/s
+2026-09-01 19:28:44,744 INFO progress=525/5397 downloaded=488 failed=37 speed=9.83 images/s
+2026-09-01 19:28:46,294 INFO progress=550/5397 downloaded=509 failed=41 speed=10.01 images/s
+2026-09-01 19:28:47,873 INFO progress=575/5397 downloaded=529 failed=46 speed=10.17 images/s
+2026-09-01 19:28:49,337 INFO progress=600/5397 downloaded=547 failed=53 speed=10.35 images/s
+2026-09-01 19:28:50,670 INFO progress=625/5397 downloaded=566 failed=59 speed=10.53 images/s
+2026-09-01 19:28:52,304 INFO progress=650/5397 downloaded=588 failed=62 speed=10.66 images/s
+2026-09-01 19:28:53,889 INFO progress=675/5397 downloaded=609 failed=66 speed=10.79 images/s
+2026-09-01 19:28:55,347 INFO progress=700/5397 downloaded=629 failed=71 speed=10.94 images/s
+2026-09-01 19:28:57,053 INFO progress=725/5397 downloaded=649 failed=76 speed=11.03 images/s
+2026-09-01 19:28:58,638 INFO progress=750/5397 downloaded=667 failed=83 speed=11.14 images/s
+2026-09-01 19:29:00,210 INFO progress=775/5397 downloaded=687 failed=88 speed=11.25 images/s
+2026-09-01 19:29:01,699 INFO progress=800/5397 downloaded=706 failed=94 speed=11.37 images/s
+2026-09-01 19:34:51,713 INFO prepared posts=9873 comments=78032/201544 unique_images=5397
+2026-09-01 19:34:54,595 INFO progress=1/5397 downloaded=1 failed=0 speed=0.04 images/s
+2026-09-01 19:34:55,144 INFO progress=25/5397 downloaded=25 failed=0 speed=1.09 images/s
+2026-09-01 19:34:57,237 INFO progress=50/5397 downloaded=49 failed=1 speed=1.99 images/s
+2026-09-01 19:34:59,230 INFO progress=75/5397 downloaded=73 failed=2 speed=2.77 images/s
+2026-09-01 19:35:01,238 INFO progress=100/5397 downloaded=98 failed=2 speed=3.44 images/s
+2026-09-01 19:35:01,918 INFO progress=125/5397 downloaded=123 failed=2 speed=4.20 images/s
+2026-09-01 19:35:04,227 INFO progress=150/5397 downloaded=147 failed=3 speed=4.68 images/s
+2026-09-01 19:35:06,339 INFO progress=175/5397 downloaded=170 failed=5 speed=5.12 images/s
+2026-09-01 19:35:08,440 INFO progress=200/5397 downloaded=195 failed=5 speed=5.51 images/s
+2026-09-01 19:35:10,469 INFO progress=225/5397 downloaded=218 failed=7 speed=5.87 images/s
+2026-09-01 19:35:11,240 INFO progress=250/5397 downloaded=242 failed=8 speed=6.40 images/s
+2026-09-01 19:35:13,418 INFO progress=275/5397 downloaded=267 failed=8 speed=6.67 images/s
+2026-09-01 19:35:15,654 INFO progress=300/5397 downloaded=290 failed=10 speed=6.90 images/s
+2026-09-01 19:35:17,690 INFO progress=325/5397 downloaded=315 failed=10 speed=7.14 images/s
+2026-09-01 19:35:18,353 INFO progress=350/5397 downloaded=340 failed=10 speed=7.58 images/s
+2026-09-01 19:35:20,561 INFO progress=375/5397 downloaded=365 failed=10 speed=7.75 images/s
+2026-09-01 19:35:22,745 INFO progress=400/5397 downloaded=389 failed=11 speed=7.91 images/s
+2026-09-01 19:35:24,964 INFO progress=425/5397 downloaded=412 failed=13 speed=8.05 images/s
+2026-09-01 19:35:26,810 INFO progress=450/5397 downloaded=428 failed=22 speed=8.23 images/s
+2026-09-01 19:35:28,040 INFO progress=475/5397 downloaded=449 failed=26 speed=8.50 images/s
+2026-09-01 19:35:30,335 INFO progress=500/5397 downloaded=469 failed=31 speed=8.60 images/s
+2026-09-01 19:35:32,715 INFO progress=525/5397 downloaded=488 failed=37 speed=8.67 images/s
+2026-09-01 19:35:34,893 INFO progress=550/5397 downloaded=508 failed=42 speed=8.77 images/s
+2026-09-01 19:35:36,339 INFO progress=575/5397 downloaded=529 failed=46 speed=8.96 images/s
+2026-09-01 19:35:38,741 INFO progress=600/5397 downloaded=547 failed=53 speed=9.01 images/s
+2026-09-01 19:35:41,097 INFO progress=625/5397 downloaded=566 failed=59 speed=9.07 images/s
+2026-09-01 19:35:43,373 INFO progress=650/5397 downloaded=588 failed=62 speed=9.13 images/s
+2026-09-01 19:35:45,217 INFO progress=675/5397 downloaded=609 failed=66 speed=9.24 images/s
+2026-09-01 19:35:46,861 INFO progress=700/5397 downloaded=629 failed=71 speed=9.37 images/s
+2026-09-01 19:35:49,140 INFO progress=725/5397 downloaded=649 failed=76 speed=9.42 images/s
+2026-09-01 19:35:51,201 INFO progress=750/5397 downloaded=669 failed=81 speed=9.49 images/s
+2026-09-01 19:35:53,162 INFO progress=775/5397 downloaded=694 failed=81 speed=9.57 images/s
+2026-09-01 19:35:54,695 INFO progress=800/5397 downloaded=713 failed=87 speed=9.69 images/s
+2026-09-01 22:56:30,188 INFO prepared posts=9873 comments=78032/201544 unique_images=5397
+2026-09-01 22:56:31,731 INFO progress=1/5397 downloaded=1 failed=0 speed=0.09 images/s
+2026-09-01 22:56:31,928 INFO progress=25/5397 downloaded=25 failed=0 speed=2.25 images/s
+2026-09-01 22:56:33,170 INFO progress=50/5397 downloaded=49 failed=1 speed=4.05 images/s
+2026-09-01 22:56:34,382 INFO progress=75/5397 downloaded=73 failed=2 speed=5.53 images/s
+2026-09-01 22:56:35,597 INFO progress=100/5397 downloaded=98 failed=2 speed=6.77 images/s
+2026-09-01 22:56:35,784 INFO progress=125/5397 downloaded=123 failed=2 speed=8.36 images/s
+2026-09-01 22:56:36,989 INFO progress=150/5397 downloaded=148 failed=2 speed=9.28 images/s
+2026-09-01 22:56:38,215 INFO progress=175/5397 downloaded=171 failed=4 speed=10.07 images/s
+2026-09-01 22:56:39,438 INFO progress=200/5397 downloaded=195 failed=5 speed=10.75 images/s
+2026-09-01 22:56:40,625 INFO progress=225/5397 downloaded=218 failed=7 speed=11.37 images/s
+2026-09-01 22:56:40,963 INFO progress=250/5397 downloaded=242 failed=8 speed=12.42 images/s
+2026-09-01 22:56:42,121 INFO progress=275/5397 downloaded=267 failed=8 speed=12.92 images/s
+2026-09-01 22:56:43,247 INFO progress=300/5397 downloaded=290 failed=10 speed=13.38 images/s
+2026-09-01 22:56:44,427 INFO progress=325/5397 downloaded=315 failed=10 speed=13.77 images/s
+2026-09-01 22:56:45,026 INFO progress=350/5397 downloaded=340 failed=10 speed=14.46 images/s
+2026-09-01 22:56:45,975 INFO progress=375/5397 downloaded=365 failed=10 speed=14.91 images/s
+2026-09-01 22:56:47,162 INFO progress=400/5397 downloaded=390 failed=10 speed=15.19 images/s
+2026-09-01 22:56:48,370 INFO progress=425/5397 downloaded=414 failed=11 speed=15.43 images/s
+2026-09-01 22:56:49,444 INFO progress=450/5397 downloaded=428 failed=22 speed=15.73 images/s
+2026-09-01 22:56:50,313 INFO progress=475/5397 downloaded=450 failed=25 speed=16.11 images/s
+2026-09-01 22:56:51,285 INFO progress=500/5397 downloaded=470 failed=30 speed=16.42 images/s
+2026-09-01 22:56:52,339 INFO progress=525/5397 downloaded=488 failed=37 speed=16.66 images/s
+2026-09-01 22:56:53,336 INFO progress=550/5397 downloaded=510 failed=40 speed=16.92 images/s
+2026-09-01 22:56:54,377 INFO progress=575/5397 downloaded=529 failed=46 speed=17.14 images/s
+2026-09-01 22:56:55,405 INFO progress=600/5397 downloaded=548 failed=52 speed=17.35 images/s
+2026-09-01 22:56:56,391 INFO progress=625/5397 downloaded=566 failed=59 speed=17.57 images/s
+2026-09-01 22:56:57,556 INFO progress=650/5397 downloaded=588 failed=62 speed=17.70 images/s
+2026-09-01 22:56:58,620 INFO progress=675/5397 downloaded=610 failed=65 speed=17.86 images/s
+2026-09-01 22:56:59,493 INFO progress=700/5397 downloaded=630 failed=70 speed=18.10 images/s
+2026-09-01 22:57:00,562 INFO progress=725/5397 downloaded=650 failed=75 speed=18.25 images/s
+2026-09-01 22:57:01,590 INFO progress=750/5397 downloaded=668 failed=82 speed=18.40 images/s
+2026-09-01 22:57:02,720 INFO progress=775/5397 downloaded=688 failed=87 speed=18.50 images/s
+2026-09-01 22:57:03,715 INFO progress=800/5397 downloaded=706 failed=94 speed=18.65 images/s
+2026-09-01 22:59:22,726 INFO prepared posts=9873 comments=78032/201544 unique_images=5397
+2026-09-01 22:59:24,311 INFO progress=1/5397 downloaded=1 failed=0 speed=0.09 images/s
+2026-09-01 22:59:24,478 INFO progress=25/5397 downloaded=25 failed=0 speed=2.32 images/s

reddit/_rescue_20260917/raw/solved_whereisthis/download_state.json

@@ -0,0 +1 @@
+{"status":"running","total_images":5397,"completed":25,"downloaded":25,"failed":0,"updated_at":1788274764.4783723}

reddit/_rescue_20260917/raw/solved_whereisthis/solved_comments.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7feef1a1ca30a5dc460f2ef7f20eaf35d3d8de9113675419abc6af4519d5436f
+size 117057811

reddit/_rescue_20260917/raw/solved_whereisthis/solved_posts_with_comments.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:649d72244c75d3a0396f99c15365b93566abf9d0e2fbf35086f565effa850f17
+size 151523413