File size: 4,313 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 | 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) # exotic method: stay correct
SLACK = 30 + 1024 # header + filename + extra
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: # filename+extra > SLACK
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
|