File size: 5,196 Bytes
04782c0
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
"""Per dataset id: meta/info.json, task strings, v2.x per-episode lengths. Metadata only. Resumable.

usage: fetch.py OUT_DIR/sample_ids.txt OUT_DIR/meta.jsonl
Appends one JSON line per id to the output file (created if missing); ids already in it with a result are skipped on a
rerun. Ids that are not plain public repository ids (namespace/name) are recorded as errors without a request.
Requests go only to huggingface.co and Hugging Face file storage (see hub.py); size limits per file are in LIMIT.
Pace: one request every GAP seconds across all P threads (defaults 0.15 s, 8 threads); a 429 reply backs off.

Episode lengths (v2): the "length" of the first 5,000 lines of meta/episodes.jsonl, so a dataset with more episodes,
or with lines missing, has fewer lengths than its total_episodes.

v3 task strings: no parquet library is used. The printable runs of 4 or more characters in meta/tasks.parquet are
taken, schema and pandas words and base64 blobs are dropped, and fragments contained in a longer one are merged. The
8 longest fragments that remain are kept.
This is a heuristic: a compressed file can split or drop a task string."""
import json, os, re, sys, time, urllib.error
from concurrent.futures import ThreadPoolExecutor
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import hub

LIMIT = {"info.json": 1 << 20, "tasks.jsonl": 4 << 20, "episodes.jsonl": 32 << 20, "tasks.parquet": 4 << 20}
SKIP = re.compile(r'^(schema|task_index|task|pandas|ARROW:schema|parquet-cpp.*|__index_level_0__)$')

import threading
_lock = threading.Lock(); _last = [0.0]; N429 = [0]
GAP = float(os.environ.get("GAP", "0.15"))  # seconds between requests, all threads (about 6-7 a second)

def get(url, limit, tries=6):
    for a in range(tries):
        with _lock:
            w = _last[0] + GAP - time.time()
            if w > 0: time.sleep(w)
            _last[0] = time.time()
        try:
            return hub.get(url, limit)[0]
        except (hub.OffOrigin, hub.TooLarge, hub.TooManyRedirects):
            raise
        except urllib.error.HTTPError as e:
            if e.code in (401, 403, 404): return None  # missing, private or gated: not public
            if e.code == 429:
                N429[0] += 1; time.sleep(20 * (a + 1)); continue
            time.sleep(3 * (a + 1))
        except Exception:
            time.sleep(3 * (a + 1))
    raise RuntimeError("failed " + url)

def parquet_tasks(b):
    """Task strings from a small tasks.parquet: printable runs, minus schema words, JSON and base64 blobs."""
    out = []
    for s in re.findall(rb'[\x20-\x7e]{4,}', b):
        s = s.decode()
        s = re.sub(r'^[^A-Za-z0-9]{1,3}', '', s).strip()
        if len(s) < 4 or SKIP.match(s) or 'parquet-cpp' in s or 'pandas_type' in s or 'index_columns' in s or '"name"' in s: continue
        if re.fullmatch(r'[A-Za-z0-9+/=]{24,}', s) or s == 'PAR1' or s.endswith('%'): continue  # base64 ARROW:schema blob
        out.append(s)
    # keep strings not contained in a longer kept one (snappy fragments)
    out = sorted(set(out), key=len, reverse=True)
    keep = []
    for s in out:
        if not any(s in k for k in keep):
            keep.append(s)
            if len(keep) == 8: break
    return keep

def one(i):
    base = f"https://huggingface.co/datasets/{i}/resolve/main/meta/"
    r = {"id": i}
    if not hub.valid_repo_id(i):
        r["err"] = "invalid id"; return r
    try:
        b = get(base + "info.json", LIMIT["info.json"])
        if b is None: r["err"] = "no info.json"; return r
        d = json.loads(b)
        r.update(robot=d.get("robot_type"), eps=d.get("total_episodes"), frames=d.get("total_frames"), fps=d.get("fps"), v=d.get("codebase_version"))
        if str(r["v"]).startswith("v2"):
            t = get(base + "tasks.jsonl", LIMIT["tasks.jsonl"])
            r["tasks"] = [json.loads(l).get("task", "")[:200] for l in (t or b"").decode(errors="replace").splitlines() if l.strip()][:8]
            e = get(base + "episodes.jsonl", LIMIT["episodes.jsonl"])
            if e is not None:
                r["lens"] = [json.loads(l).get("length") for l in e.decode(errors="replace").splitlines() if l.strip()][:5000]
        else:
            t = get(base + "tasks.parquet", LIMIT["tasks.parquet"])
            r["tasks"] = [s[:200] for s in parquet_tasks(t)] if t else []
    except Exception as ex:
        r["err"] = repr(ex)[:120]
    return r

if len(sys.argv) < 3:
    sys.exit(__doc__)
ids = [l.strip() for l in open(sys.argv[1]) if l.strip()]
done = set()
if os.path.exists(sys.argv[2]):
    for l in open(sys.argv[2]):
        try:
            x = json.loads(l)
            if "err" not in x or x["err"] == "no info.json": done.add(x["id"])
        except Exception: pass
todo = [i for i in ids if i not in done]
print("todo", len(todo), "done", len(done), flush=True)
t0 = time.time(); n = 0
with ThreadPoolExecutor(int(os.environ.get("P", "8"))) as ex, open(sys.argv[2], "a") as f:
    for r in ex.map(one, todo):
        f.write(json.dumps(r) + "\n"); f.flush(); n += 1
        if n % 250 == 0: print(n, round(time.time() - t0), "429s", N429[0], flush=True)
print("DONE", n, round(time.time() - t0), "429s", N429[0])