| import io, struct, zipfile, zlib, requests |
| from requests.adapters import HTTPAdapter |
| from urllib3.util.retry import Retry |
|
|
| HF = "https://huggingface.co/datasets/nkp37/OpenVid-1M/resolve/main" |
|
|
| def make_session(total=10, backoff=1.5): |
| """Session that transparently retries 429/5xx with exponential backoff, |
| honouring Retry-After when HF sends it.""" |
| s = requests.Session() |
| r = Retry(total=total, connect=total, read=total, status=total, |
| backoff_factor=backoff, |
| status_forcelist=[429, 500, 502, 503, 504], |
| allowed_methods=["GET", "HEAD"], |
| respect_retry_after_header=True, |
| raise_on_status=False) |
| ad = HTTPAdapter(max_retries=r, pool_connections=64, pool_maxsize=64) |
| s.mount("https://", ad); s.mount("http://", ad) |
| return s |
| SPLIT_PARTS = {73,76,78,83,88,89,92,95,96,102,103,111,118,183,184,185} |
|
|
| def part_urls(i): |
| if i in SPLIT_PARTS: |
| return [f"{HF}/OpenVid_part{i}_partaa", f"{HF}/OpenVid_part{i}_partab"] |
| return [f"{HF}/OpenVid_part{i}.zip"] |
|
|
| class RangeFile(io.RawIOBase): |
| """Several URLs concatenated into one seekable read-only file.""" |
| def __init__(self, urls, session=None, timeout=60): |
| self.urls, self.s, self.timeout = list(urls), session or make_session(), timeout |
| self.sizes = [int(self.s.head(u, allow_redirects=True, timeout=timeout) |
| .headers["Content-Length"]) for u in self.urls] |
| self.offs, acc = [], 0 |
| for sz in self.sizes: |
| self.offs.append(acc); acc += sz |
| self.size, self.pos, self.bytes_fetched = acc, 0, 0 |
|
|
| def seek(self, off, whence=0): |
| self.pos = off if whence == 0 else (self.pos + off if whence == 1 else self.size + off) |
| return self.pos |
| def tell(self): return self.pos |
| def seekable(self): return True |
| def readable(self): return True |
|
|
| def read(self, n=-1): |
| n = self.size - self.pos if (n is None or n < 0) else min(n, self.size - self.pos) |
| if n <= 0: return b"" |
| out = bytearray() |
| while n > 0: |
| k = max(j for j, o in enumerate(self.offs) if o <= self.pos) |
| local = self.pos - self.offs[k] |
| take = min(n, self.sizes[k] - local) |
| r = self.s.get(self.urls[k], headers={"Range": f"bytes={local}-{local+take-1}"}, |
| allow_redirects=True, timeout=self.timeout) |
| r.raise_for_status() |
| out += r.content |
| self.pos += len(r.content); n -= len(r.content); self.bytes_fetched += len(r.content) |
| if len(r.content) < take: break |
| return bytes(out) |
|
|
| def open_part(i, session=None): |
| rf = RangeFile(part_urls(i), session or make_session()) |
| return zipfile.ZipFile(rf), rf |
|
|
|
|
| def read_member(z, rf, member): |
| """Read one zip member with a SINGLE HTTP Range request. |
| |
| zipfile.ZipFile.read() costs 3-4 round trips per member (local header, file |
| name, extra field, payload). Over HTTP that is latency- and request-rate- |
| bound, and HF throttles on request count, so we fetch |
| [local header .. end of payload] in one go and parse the 30-byte header |
| locally. Members are deflated; zlib with a raw (-15) window undoes that. |
| """ |
| zi = z.getinfo(member) |
| if zi.compress_type not in (zipfile.ZIP_STORED, zipfile.ZIP_DEFLATED): |
| return z.read(member) |
| SLACK = 30 + 1024 |
| rf.seek(zi.header_offset) |
| blob = rf.read(SLACK + zi.compress_size) |
| if len(blob) < 30 or blob[:4] != b"PK\x03\x04": |
| raise IOError(f"bad local header for {member}") |
| fnl, exl = struct.unpack("<HH", blob[26:30]) |
| off = 30 + fnl + exl |
| raw = blob[off:off + zi.compress_size] |
| if len(raw) < zi.compress_size: |
| rf.seek(zi.header_offset + off + len(raw)) |
| raw += rf.read(zi.compress_size - len(raw)) |
| if len(raw) != zi.compress_size: |
| raise IOError(f"short read {member}: {len(raw)}/{zi.compress_size}") |
| data = raw if zi.compress_type == zipfile.ZIP_STORED else zlib.decompress(raw, -15) |
| if len(data) != zi.file_size: |
| raise IOError(f"bad size {member}: {len(data)}/{zi.file_size}") |
| return data |
|
|
