File size: 5,475 Bytes
d8a0e2f | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 | import argparse, collections, csv, json, os, sys, threading, time
import requests
from concurrent.futures import ThreadPoolExecutor, as_completed
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from hfzip import open_part, make_session, read_member
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
csv.field_size_limit(10**9)
ap = argparse.ArgumentParser()
ap.add_argument("--manifest", default=os.path.join(ROOT, "meta", "manifest.csv"))
ap.add_argument("--budget-gb", type=float, default=None)
ap.add_argument("--out", default=os.path.join(ROOT, "videos"))
ap.add_argument("--workers", type=int, default=16)
ap.add_argument("--chunk", type=int, default=150, help="clips per worker task (allows >1 thread per zip part)")
ap.add_argument("--limit", type=int, default=None, help="benchmark: only first N clips")
ap.add_argument("--retries", type=int, default=4)
args = ap.parse_args()
os.makedirs(args.out, exist_ok=True)
jobs = []
with open(args.manifest, newline="") as f:
for r in csv.DictReader(f):
if args.budget_gb and float(r["cum_gb"]) > args.budget_gb:
break
jobs.append({"video": r["video"], "member": r["member"],
"part": int(r["part"]), "bytes": int(r["bytes"])})
if args.limit:
jobs = jobs[:args.limit]
total_jobs = len(jobs)
total_bytes = sum(j["bytes"] for j in jobs)
jobs = [j for j in jobs if not os.path.exists(os.path.join(args.out, j["video"]))]
print(f"manifest jobs: {total_jobs:,} ({total_bytes/1e9:.1f} GB) | todo: {len(jobs):,} "
f"({sum(j['bytes'] for j in jobs)/1e9:.1f} GB) | already on disk: {total_jobs-len(jobs):,}", flush=True)
by_part = collections.defaultdict(list)
for j in jobs:
by_part[j["part"]].append(j)
# split each part's jobs into chunks -> several threads may work the same part
tasks = []
for p, js in sorted(by_part.items()):
for k in range(0, len(js), args.chunk):
tasks.append((p, js[k:k+args.chunk]))
tasks.sort(key=lambda t: -len(t[1]))
print(f"parts: {len(by_part)} | tasks: {len(tasks)} | workers: {args.workers}", flush=True)
LOCK = threading.Lock()
THROTTLE_UNTIL = [0.0]
def note_throttle(e, secs=20):
"""Global brake: when HF starts 429-ing, every thread pauses."""
if "429" in str(e) or "Too Many Requests" in str(e):
with LOCK:
THROTTLE_UNTIL[0] = max(THROTTLE_UNTIL[0], time.time() + secs)
def wait_throttle():
while True:
with LOCK:
t = THROTTLE_UNTIL[0]
d = t - time.time()
if d <= 0:
return
time.sleep(min(d, 5))
STAT = dict(got=0, failed=0, nbytes=0, t0=time.time())
STOP = threading.Event()
def bump(got=0, failed=0, nbytes=0):
with LOCK:
STAT["got"] += got; STAT["failed"] += failed; STAT["nbytes"] += nbytes
def reporter():
last = 0
while not STOP.wait(30):
with LOCK:
g, fl, nb, t0 = STAT["got"], STAT["failed"], STAT["nbytes"], STAT["t0"]
el = time.time() - t0
inst = (nb - last) / 30 / 1e6
last = nb
eta = (len(jobs) - g) / (g / el) / 3600 if g else float("nan")
print(f"[{time.strftime('%H:%M:%S')}] {g:,}/{len(jobs):,} clips {nb/1e9:.1f} GB "
f"avg {nb/el/1e6:.0f} MB/s now {inst:.0f} MB/s fail {fl} ETA {eta:.1f} h", flush=True)
def fetch_task(part, todo):
s = make_session()
z = rf = None
for attempt in range(args.retries):
try:
z, rf = open_part(part, s); break
except Exception as e:
if attempt == args.retries - 1:
bump(failed=len(todo))
return part, 0, len(todo), f"open_part failed: {e}"
time.sleep(3 * (attempt + 1))
got = failed = 0
for j in todo:
wait_throttle()
dst = os.path.join(args.out, j["video"])
if os.path.exists(dst):
continue
tmp = dst + f".part{threading.get_ident()}"
for attempt in range(args.retries):
try:
data = read_member(z, rf, j["member"])
with open(tmp, "wb") as fh:
fh.write(data)
os.replace(tmp, dst)
got += 1
bump(got=1, nbytes=len(data))
break
except Exception as e:
note_throttle(e)
try: os.path.exists(tmp) and os.remove(tmp)
except Exception: pass
if attempt == args.retries - 1:
failed += 1; bump(failed=1)
print(f" [FAIL] {j['video']} part{part}: {e}", flush=True)
else:
wait_throttle()
time.sleep(3 * (attempt + 1))
try:
z, rf = open_part(part, s) # re-open on error
except Exception:
pass
return part, got, failed, "ok"
th = threading.Thread(target=reporter, daemon=True); th.start()
with ThreadPoolExecutor(max_workers=args.workers) as ex:
futs = [ex.submit(fetch_task, p, js) for p, js in tasks]
done = 0
for fut in as_completed(futs):
done += 1
try:
fut.result()
except Exception as e:
print(f" [TASK ERR] {e}", flush=True)
STOP.set()
el = time.time() - STAT["t0"]
print(f"DONE got={STAT['got']:,} failed={STAT['failed']:,} "
f"{STAT['nbytes']/1e9:.1f} GB in {el/60:.1f} min ({STAT['nbytes']/el/1e6:.0f} MB/s)", flush=True)
|