File size: 44,847 Bytes
bd4b538
 
 
 
 
cc02077
 
 
bd4b538
 
92df43e
 
 
bd4b538
 
 
 
 
5b9f5a4
 
bd4b538
 
 
 
 
 
 
 
 
 
 
 
5b9f5a4
bd4b538
135ad7c
bd4b538
 
 
 
5b9f5a4
 
 
bd4b538
 
 
5b9f5a4
bd4b538
cc02077
bd4b538
 
 
 
 
 
cc02077
bd4b538
5b9f5a4
bd4b538
 
 
 
5b9f5a4
 
 
bd4b538
 
cc02077
 
bd4b538
 
 
 
cc02077
bd4b538
5b9f5a4
bd4b538
 
 
cc02077
bd4b538
 
5b9f5a4
 
cc02077
bd4b538
 
 
cc02077
bd4b538
 
 
5b9f5a4
bd4b538
 
5b9f5a4
bd4b538
 
 
cc02077
bd4b538
 
370e5d0
f4b175e
cc02077
f4b175e
370e5d0
bd4b538
f4b175e
bd4b538
 
 
cc02077
bd4b538
 
 
 
 
cc02077
 
bd4b538
 
 
5b9f5a4
cc02077
 
5dcfab0
c302b8d
cc02077
c302b8d
cc02077
bd4b538
 
 
cc02077
 
5b9f5a4
bd4b538
 
 
2f79f80
 
 
 
 
 
 
bd4b538
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
cc02077
5b9f5a4
bd4b538
 
 
 
 
 
 
 
 
 
 
 
cc02077
bd4b538
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5b9f5a4
bd4b538
 
 
 
 
2f79f80
bd4b538
 
 
 
cc02077
bd4b538
 
 
 
 
2f79f80
bd4b538
 
 
 
 
5b9f5a4
bd4b538
cc02077
bd4b538
cc02077
bd4b538
cc02077
bd4b538
 
5b9f5a4
bd4b538
 
 
4529577
bd4b538
 
 
 
5b9f5a4
bd4b538
 
 
 
 
5b9f5a4
bd4b538
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5b9f5a4
bd4b538
2f79f80
bd4b538
5b9f5a4
cc02077
 
bd4b538
 
 
 
 
 
2f79f80
bd4b538
 
 
 
2f79f80
bd4b538
5b9f5a4
cc02077
 
 
bd4b538
 
 
 
 
 
 
 
 
 
 
 
 
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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
# 挑选行

[English](selecting.md) | 简体中文

本仓库中的每张表都是 Parquet。
`data/` 下数据文件的一行是一个可下载的条目:一个文件、一个存档成员、一条 WARC 记录、一个字节范围或一个 API 响应。
它的 `source` 和 `batch` 列说明它属于哪个来源和批次;文件的路径不说明这些,一个文件可能存放几个来源的行。
`meta/catalog.parquet` 的 `data_files` 列列出每个来源的文件,`batch_files` 列列出每个批次的文件。
`meta/` 下的表都很小,说明哪些行值得使用。

每个快照中每个键(source、uri、range_offset 和 member_path)只有一行:更正后的行替换旧行,存放旧行的文件去掉它后被整个重写。
每个文件以前的状态留在数据集仓库的历史和它的发布标签中。

## 行字段

| 字段 | 含义 |
|---|---|
| `source` | 来源名称(见 meta/sources.json)。 |
| `batch` | 来源内部的批次(一次快照或一次采集运行)。 |
| `collection` | 来源内部的分组名称。 |
| `ext` | 不带点的文件扩展名,照来源处所见。 |
| `uri` | 下载地址(来源提供 HTTPS 时为 HTTPS)。 |
| `range_offset, range_length` | uri 所指文件中的字节范围,用于存放在更大文件中的记录。 |
| `member_path, parent_pointer_id` | 存档中成员的路径,以及该存档的指针。 |
| `zip_local_header_offset, zip_compression_method, zip_compressed_size` | zip 成员的字节在哪里,以便用范围请求读取。 |
| `size_bytes` | 条目的字节数(来源没有说明时为空)。 |
| `media_type` | 来源声明了媒体类型时的媒体类型。 |
| `sha256, sha1, md5, crc32` | 原始字节形式的哈希值;十六进制形式用 lower(hex(sha256))。 |
| `origin_url, origin_time` | 发现该条目的页面(已去掉签名和凭据参数)及其抓取时间。 |
| `truncated` | 存储的内容为什么被截断(没有截断时为空)。 |
| `license_spdx, license_training_ok, license_redistribution_ok, license_notes` | 与批次许可证不同时,该行自己的许可证。 |
| `sensitive` | 该行的数据涉及健康或未成年人时为 health 或 minors(否则为空);按它筛选可以去掉这些行。 |
| `collected_at` | 该行被采集的时间(UTC,YYYY-MM-DDTHH:MM:SSZ):采集器写出该行所在分片时记录的时间(选集来源为采集器发出该行所在文件的时间),该行的文件重写时保持不变;同一键下的多行中,快照保留最后采集的那一行。没有记录时间时为空(加入该列之前写入的行,或采集器开始记录时间之前采集的行);这样的行按其批次日期的 UTC 零点排序;批次名称中没有日期时,排在所有有时间的行之下。 |
| `extra` | 完整指针带有的其他内容,为 JSON;fetch.py 由它重建完整指针。 |
| `row_file, row_index` | 该行所在的位置:数据文件(它在 data/ 下的路径,meta/bench_checked.parquet 也用这个名字列出它)和其中从 0 开始的行号。不存储在数据文件中;tools/fetch.py 读取时加上。 |

## meta/ 下的表

- `meta/batches.parquet`:每个来源和批次一行:许可证等级(training_ok、redistribution_ok)、tools/fetch.py 使用的总体大小上限(max_size_bytes)、内容类别,以及用来重建完整指针的常量和规则。
- `meta/bench_overlap.parquet`:在公开基准测试任务中找到的行,以及位于基准测试清单列出的某个 GitHub 代码仓库或其某个分叉地址上的行:范围 row 匹配一行,范围 container 匹配整个分组;hit_class 说明匹配是怎样得出的(docs/fields.zh.md 的“基准测试重叠类别”一节说明每个类别)。一行是基准测试数据的副本(benchmark_copy)时,只有当它的分组本身是一个完整单元(一个软件包、代码仓库、数据集或模型仓库;meta/sources.json 中 collection_kind 为 "unit",bucket_collections 中列出的分组除外)时,才列出整个分组。分组是分桶(按文件类型、抓取、日期、站点之类)时,只列出那一行。每次发布都把每个已发布的数据文件与基准测试清单比对(键版本记在 meta/projection.json 的 bench_keys 中);表按来源排序。
- `meta/bench_checked.parquet`:哪些数据文件与基准测试清单比对过:范围 file 为每个已发布的数据文件(row_file)一行,checked 为 true,并带有文件的 SHA-256(sha256)。每次发布都比对每个已发布的数据文件,所以本表没有列出的文件属于索引的较旧修订,算作没有比对过。范围 container 列出名称与某个基准测试相符、正在等待裁定的分组(reason 为 pending_ruling)。default_keep 说明默认筛选是否保留这些行;表按来源排序。
- `meta/tags.parquet`:合集标签 `campaign:<name>`:对每个来源、批次、分组、扩展名、元数据值和内容类别,列出属于该合集的行,附行数和批次的大小上限(max_size_bytes);`tools/fetch.py --tag campaign:<name>` 选出它们。来源的主题和形式不是标签:它们是 `meta/catalog.parquet` 的 `domain` 和 `form` 列。
- `meta/size_caps.json`:参考大小上限:所有基准测试任务文件的总体上限(它们大小的第 99 百分位)、它是怎样得出的(样本数、百分位、值)以及怎样重新校准;暂定值。它不会去掉行:tools/fetch.py 在下载时使用它。
- `meta/selecting.json`:选择构建上一次构建 meta/ 下各表的记录(那次构建的计数、它所检查的基准测试清单和日期,以及运行时间);本页不再显示其中按来源的计数:meta/catalog.parquet 是来源列表,每次发布都带有它们的计数。
- `meta/sources.json`:每个来源的详情,包括用来重建完整指针的布局。
- `meta/coverage.json`:按许可证等级、来源、单元、大小和合集标签的合计;`projections.license_unknown` 列出等级为 unknown 的许可证写法。

`cards/<source>.yaml` 是一个来源的卡片:说明一个来源的文件是什么(类型、结构、可以用来构建什么任务、风险),样本是怎样抽取和阅读的,并对每个字段给出 `evidence.<field>.fill`:auto(构建卡片时从索引算出;`checked_at` 是那一天)、judgment(来自下载并读过的样本文件,附依据和所用的文件)、derived(基于其他字段的固定规则)或 unfilled(还没有依据)。
卡片不会随每次上传重建。
依赖某个字段之前,先读它的依据;比例按样本计,不按整个来源计。
[卡片各字段可信到什么程度](#卡片各字段可信到什么程度)有更多说明。

## 默认筛选

默认子集只包含与基准测试清单(AA-Briefcase-Lite, AA-Omniscience, Agents' Last Exam, Aider Polyglot, AndroidWorld, AutomationBench, BrowseComp, BrowseComp-Plus, COCO, CyberGym, DeepSWE, EnterpriseOps-Gym, ExploitGym, Finance Agent, FrontierSWE v2, GDPval, GraphWalks, Harvey LAB, LHTB, LibriSpeech, MCP Atlas, MCPMark, Multi-SWE-bench, NL2Repo, OSWorld, OSWorld 2, ProofNet, PutnamBench, SEC-bench Pro, SWE-bench Multilingual, SWE-bench Multimodal, SWE-bench Pro, SWE-bench Verified, SWE-sweep, SciCode, Terminal-Bench, Toolathlon, WideSearch, miniF2F, tau2-bench)(截至 2026-11-08)比对过的数据文件中的行,并去掉其中发现的基准测试数据副本和同一文件的重复副本。
每次发布都比对每个已发布的数据文件(发布时会对所有数据文件构建 meta/bench_overlap.parquet 和 meta/bench_checked.parquet),所以 meta/bench_checked.parquet 列出本修订的每个数据文件;它没有列出的文件属于索引的较旧修订,算作没有比对过。
等待裁定的分组的行也不包括在内。
许可证等级、大小和版本不会去掉行;下面的查询按它们挑选。
被截断的行和空文件保留;下面的参考计数会计入它们。
一行在以下各条都成立时通过:

- `not_in_benchmark_row / not_in_benchmark_container`:该行及其分组没有以命中类别 benchmark_copy, task_file, data_address 出现在 meta/bench_overlap.parquet 中(在比对过的行中发现的基准测试数据副本,包括从基准测试派生的分组,以及位于基准测试清单列出的某个 GitHub 代码仓库或其某个分叉地址上的行)。
- `checked_for_benchmarks`:该行的数据文件在 meta/bench_checked.parquet 中列为已与基准测试清单比对(checked 为 true),并且它的分组没有在那里列为等待裁定;每个已发布的数据文件都被列出,所以只有从索引较旧修订读到的行不满足这一条。
- `not_duplicate`:在查询读到的行中,该行不是上面各条保留下来的另一行的重复副本:每个快照中每个自然键(source、uri、range_offset、member_path)只有一行,但在此之前写成的版本可能有多行,这时只保留按采集时间最新的版本:最晚的批次,其次是该批次最晚的分片文件(分片文件按写入顺序编号;这样的版本把更正后的行写进新的分片文件,旧版本仍留在原处),再次是文件中的最后一行(natural_key_conflict 为 true);被更新批次取代的快照的行被去掉(stackexchange-dump 按 source_meta.site);sha256、sha1 或 md5(md5 还要 size_bytes 相同)相同、并且哈希范围相同的行只保留一份,依次按来源在 meta/batches.parquet 中的 registry_order,再按 source、batch、uri、range_offset、member_path、row_file 和 row_index 取第一份。它用窗口函数在查询自身的行上判定,所以保留的那份一定是查询返回的:只查询一个来源时,副本在另一个来源中的行仍会保留。

`tools/fetch.py` 把它作为默认配置的三条标准来执行(benchmark,与基准测试相符的行;not compared,还没有与基准测试清单比对过的行,另行计数;duplicate,在其他各条标准保留下来的单元上最后判定),默认配置还会去掉许可证不允许随附分发文件的行、记录为英语以外语言的行、标为带有个人数据的来源或行,以及大于 20 MB 的行;它会打印每条标准去掉了多少个单元。
每条标准都有自己的选项(`--keep-duplicates`、`--allow-benchmark`、`--allow-not-compared`、`--any-license`、`--any-language`、`--allow-personal-data`、`--any-size`);
`--all` 关闭除 benchmark 和 not compared 以外的每条标准,所以与基准测试相符的行只有加上 `--allow-benchmark` 才会进入选择,还没有比对过的行只有加上 `--allow-not-compared` 或 `--allow-benchmark` 才会进入选择。
大小上限只在下载时起作用:默认是 meta/size_caps.json 的总体上限(所有基准测试任务文件的第 99 百分位),在默认配置下最多 20 MB,以防特别大的文件;`--max-size N` 使用 N 字节。
超过上限的行记为 too_large,不下载;大小未知的行最多下载到上限为止。
`--max-size` 只限制下载:超过上限的行仍留在选择中,也留在 `_meta/fetch_manifest.jsonl` 中。

## 单元和文件

材料集的行(批次名 `<name>`,标签 `campaign:<name>`)在 `extra.source_meta` 中记录它们在任务中的位置(`tools/fetch.py` 把它们复制进清单):

| 字段 | 含义 |
|---|---|
| `unit_group` | 该行所属的单元:一个测试用例、一个工作簿、一个软件包;一个单元的各个文件共用这个值。来源的 README.md 和 LICENSE 没有它。 |
| `pool_path`, `pool_leaf`, `pool_domain` | 文件在任务结构中的位置,以及它所属单元的领域叶子。 |

单元是上游作为一件东西发布的一组文件;它的键 `unit_id` 在 README.zh.md 的术语中定义。
语料库没有单元分组:它按行计数,`tools/fetch.py` 逐行取它,每行以它自己的键作为 `unit_id`。
`meta/catalog.parquet` 在 `units` 和 `files` 列中给出每个来源的计数;它就是来源列表,本页不保留按来源的表。
列出一个来源的单元:

```sql
SELECT json_extract_string(p.extra, '$.source_meta.unit_group') AS unit_group, count(*) AS files
FROM p WHERE p.source = '<source>' GROUP BY ALL ORDER BY 1;
```

## 仍在采集中的批次

构建本页时,这些批次在 meta/batches.parquet 中的状态是 `collecting`,所以上面的计数还会增长。
从本页的一次构建到下一次都留在这个列表中的批次,是长期进行的采集。

| 来源 | 批次 | 目前行数 |
|---|---|---:|
| appsec-trees | all | 383,432 |
| asciinema | all | 5 |
| bioinformatics-public-archives | all | 278,202 |
| fedora-copr-build-results | all | 552,200 |
| fedora-koji-build-logs | all | 561,233 |
| gerrit-code-review | all | 4,061,745 |
| github-release-assets | all | 200,439 |
| habs-haer-hals | all | 2,673 |
| harvard-dataverse | all | 1,191,607 |
| hf-training-records | all | 487,960 |
| internet-archive-open-licensed | all | 4,228,665 |
| kaggle-file-listings | all | 239,737 |
| launchpad-ubuntu-bugs | all | 174,719 |
| mendeley-data | all | 15,943,934 |
| modelscope | all | 8,726,153 |
| mozilla-treeherder-ci-logs | all | 37,531 |
| npm | all | 61,099,255 |
| nuget | all | 1,559,773 |
| openqa-os-test-results | all | 6,839 |
| owid-charts | all | 3,730 |
| pmc-open-access | all | 19,814,026 |
| reddit-threads-arctic-shift | all | 318,856 |
| rubygems | all | 1,019,540 |
| solver-benchmark-instances | all | 215,670 |
| zbmath-open | all | 1,576,296 |
| appsec-trees | inc | 110,819 |
| fedora-koji-build-logs | inc | 82,745 |
| harvard-dataverse | inc | 48,586 |
| hf-training-records | inc | 2,215 |
| mendeley-data | inc | 110,931 |
| npm | inc | 31,328,781 |
| pmc-open-access | inc | 4,420,485 |

## 用 DuckDB 查询

先运行一次下面的语句(DuckDB 1.1 或更新的版本能读取 `hf://` 路径,并支持 `SET VARIABLE`;设置 `HF_TOKEN` 可以提高速率限制)。
第一条语句读取 `meta/catalog.parquet`,它的 `data_files` 列列出存放每个来源各行的数据文件;视图 `p` 只读这些文件,所以没有请求会列出 `data/` 下的文件夹。
它们定义下文用到的视图:`p` 行,`b` 批次,`o` 基准测试重叠,`c` 基准测试检查覆盖,`t` 合集标签。
重复没有对应的表:视图 `selected` 在它自己的行中找出重复。

```sql
SET VARIABLE data_files = (SELECT list('hf://datasets/Battam/training-data-foundation/' || f ORDER BY f) FROM (SELECT DISTINCT unnest(data_files) AS f FROM read_parquet('hf://datasets/Battam/training-data-foundation/meta/catalog.parquet')));
CREATE OR REPLACE VIEW p AS SELECT * EXCLUDE (filename, file_row_number), replace(substr(filename, length('hf://datasets/Battam/training-data-foundation/data/') + 1), '\', '/') AS row_file, file_row_number AS row_index FROM read_parquet(getvariable('data_files'), union_by_name = true, filename = true, file_row_number = true);
CREATE OR REPLACE VIEW b AS SELECT * FROM read_parquet('hf://datasets/Battam/training-data-foundation/meta/batches.parquet');
CREATE OR REPLACE VIEW o AS SELECT * FROM read_parquet('hf://datasets/Battam/training-data-foundation/meta/bench_overlap.parquet');
CREATE OR REPLACE VIEW t AS SELECT * FROM read_parquet('hf://datasets/Battam/training-data-foundation/meta/tags.parquet');
CREATE OR REPLACE VIEW c AS SELECT * FROM read_parquet('hf://datasets/Battam/training-data-foundation/meta/bench_checked.parquet');
CREATE OR REPLACE VIEW s AS SELECT source, domain, form, pii.level AS pii_level, license.spdx AS spdx, files FROM read_parquet('hf://datasets/Battam/training-data-foundation/meta/catalog.parquet');
CREATE OR REPLACE VIEW selected AS
SELECT * EXCLUDE (duplicate_reason) FROM (
SELECT * EXCLUDE (dup_scope, dup_sha256, dup_sha1, dup_md5, dup_unit, dup_ord, dup_date, dup_sdate, dup_rev, dup_sup, dup_nk_rank, dup_nk_n, dup_r_sha256, dup_r_sha1, dup_r_md5),
  CASE WHEN dup_nk_rank > 1 THEN 'natural_key' WHEN dup_sup THEN 'superseded' WHEN dup_r_sha256 > 1 THEN 'same_sha256' WHEN dup_r_sha1 > 1 THEN 'same_sha1' WHEN dup_r_md5 > 1 THEN 'same_md5' END AS duplicate_reason,
  dup_nk_n > 1 AND dup_nk_rank = 1 AS natural_key_conflict
FROM (SELECT *,
  CASE WHEN dup_sha256 IS NOT NULL THEN row_number() OVER (PARTITION BY dup_scope, dup_sha256 ORDER BY dup_sup, dup_nk_rank > 1, dup_ord, source, batch, uri, range_offset, member_path, row_file, row_index) END AS dup_r_sha256, CASE WHEN dup_sha1 IS NOT NULL THEN row_number() OVER (PARTITION BY dup_scope, dup_sha1 ORDER BY dup_sup, dup_nk_rank > 1, dup_ord, source, batch, uri, range_offset, member_path, row_file, row_index) END AS dup_r_sha1, CASE WHEN dup_md5 IS NOT NULL THEN row_number() OVER (PARTITION BY dup_scope, dup_md5, size_bytes ORDER BY dup_sup, dup_nk_rank > 1, dup_ord, source, batch, uri, range_offset, member_path, row_file, row_index) END AS dup_r_md5
FROM (SELECT *, row_number() OVER (PARTITION BY source, uri, range_offset, member_path ORDER BY dup_sup, dup_date DESC, dup_rev DESC, batch DESC, row_file DESC, row_index DESC) AS dup_nk_rank,
  count(*) OVER (PARTITION BY source, uri, range_offset, member_path) AS dup_nk_n
FROM (SELECT *, dup_unit IS NOT NULL AND batch <> arg_max(batch, struct_pack(d := dup_sdate, r := dup_rev, b := batch)) OVER (PARTITION BY source, dup_unit) AS dup_sup
FROM (SELECT * REPLACE (CASE WHEN length(dup_sha256) = 64 AND regexp_full_match(dup_sha256, '[0-9a-f]+') THEN dup_sha256 END AS dup_sha256, CASE WHEN length(dup_sha1) = 40 AND regexp_full_match(dup_sha1, '[0-9a-f]+') THEN dup_sha1 END AS dup_sha1, CASE WHEN length(dup_md5) = 32 AND regexp_full_match(dup_md5, '[0-9a-f]+') AND size_bytes IS NOT NULL THEN dup_md5 END AS dup_md5),
  contains(lower(batch), 'revised') AS dup_rev
FROM (SELECT p.*, (CASE WHEN starts_with(coalesce(p.extra, ''), '{"_row":') THEN json_extract_string(p.extra, '$._row.pointer_id') WHEN coalesce(json_contains(json_extract(p.extra, '$._absent'), '"pointer_id"'), false) THEN NULL WHEN json_type(p.extra, '$.pointer_id') IS NOT NULL THEN json_extract_string(p.extra, '$.pointer_id') WHEN json_type(p.extra, '$.pid') IS NOT NULL THEN p.source || ':' || p.collection || ':' || json_extract_string(p.extra, '$.pid') WHEN p.parent_pointer_id IS NOT NULL AND p.member_path IS NOT NULL THEN CASE WHEN length(p.parent_pointer_id) - length(replace(p.parent_pointer_id, ':', '')) >= 2 THEN p.source || ':' || p.collection || ':' || substr(p.parent_pointer_id, strpos(p.parent_pointer_id, ':') + strpos(substr(p.parent_pointer_id, strpos(p.parent_pointer_id, ':') + 1), ':') + 1) || '!/' || p.member_path END WHEN b.pid_segments IS NOT NULL THEN p.source || ':' || p.collection || ':' || array_to_string(list_slice(string_split((CASE WHEN b.uri_swap_to IS NOT NULL AND json_extract_string(p.extra, '$._uri_orig') IS NULL THEN CASE WHEN starts_with(p.uri, b.uri_swap_to) AND ends_with(p.uri, b.uri_swap_suffix) AND length(p.uri) >= length(b.uri_swap_to) + length(b.uri_swap_suffix) THEN b.uri_swap_from || substr(p.uri, length(b.uri_swap_to) + 1, length(p.uri) - length(b.uri_swap_to) - length(b.uri_swap_suffix)) END ELSE p.uri END), '/'), -b.pid_segments, -1), '/') || CASE WHEN b.pid_at_offset THEN '@' || CAST(p.range_offset AS VARCHAR) ELSE '' END END) AS pointer_id, p.size_bytes IS NULL AS size_unknown,
  (CASE WHEN coalesce(nullif(CASE WHEN starts_with(coalesce(p.extra, ''), '{"_row":') THEN json_extract_string(p.extra, '$._row.license_override.training_ok') WHEN json_type(p.extra, '$.license_override') IS NOT NULL THEN json_extract_string(p.extra, '$.license_override.training_ok') WHEN (p.license_spdx IS NOT NULL OR p.license_training_ok IS NOT NULL OR p.license_redistribution_ok IS NOT NULL OR p.license_notes IS NOT NULL) THEN p.license_training_ok WHEN NOT coalesce(json_contains(json_extract(p.extra, '$._absent'), '"license_override"'), false) THEN b.const_training_ok END, ''), b.training_ok) IN ('yes', 'conditional', 'no') THEN coalesce(nullif(CASE WHEN starts_with(coalesce(p.extra, ''), '{"_row":') THEN json_extract_string(p.extra, '$._row.license_override.training_ok') WHEN json_type(p.extra, '$.license_override') IS NOT NULL THEN json_extract_string(p.extra, '$.license_override.training_ok') WHEN (p.license_spdx IS NOT NULL OR p.license_training_ok IS NOT NULL OR p.license_redistribution_ok IS NOT NULL OR p.license_notes IS NOT NULL) THEN p.license_training_ok WHEN NOT coalesce(json_contains(json_extract(p.extra, '$._absent'), '"license_override"'), false) THEN b.const_training_ok END, ''), b.training_ok) ELSE 'unknown' END) AS training_tier,
  (CASE WHEN coalesce(nullif(CASE WHEN starts_with(coalesce(p.extra, ''), '{"_row":') THEN json_extract_string(p.extra, '$._row.license_override.redistribution_ok') WHEN json_type(p.extra, '$.license_override') IS NOT NULL THEN json_extract_string(p.extra, '$.license_override.redistribution_ok') WHEN (p.license_spdx IS NOT NULL OR p.license_training_ok IS NOT NULL OR p.license_redistribution_ok IS NOT NULL OR p.license_notes IS NOT NULL) THEN p.license_redistribution_ok WHEN NOT coalesce(json_contains(json_extract(p.extra, '$._absent'), '"license_override"'), false) THEN b.const_redistribution_ok END, ''), b.redistribution_ok) IN ('yes', 'conditional', 'no') THEN coalesce(nullif(CASE WHEN starts_with(coalesce(p.extra, ''), '{"_row":') THEN json_extract_string(p.extra, '$._row.license_override.redistribution_ok') WHEN json_type(p.extra, '$.license_override') IS NOT NULL THEN json_extract_string(p.extra, '$.license_override.redistribution_ok') WHEN (p.license_spdx IS NOT NULL OR p.license_training_ok IS NOT NULL OR p.license_redistribution_ok IS NOT NULL OR p.license_notes IS NOT NULL) THEN p.license_redistribution_ok WHEN NOT coalesce(json_contains(json_extract(p.extra, '$._absent'), '"license_override"'), false) THEN b.const_redistribution_ok END, ''), b.redistribution_ok) ELSE 'unknown' END) AS redistribution_tier,
  coalesce((SELECT bool_and(c.checked) FROM c WHERE c.scope = 'file' AND c.row_file = p.row_file), false) AND NOT EXISTS (SELECT 1 FROM c WHERE c.scope = 'container' AND NOT c.checked AND c.source = p.source AND c.collection = split_part(p.collection, '@', 1)) AS checked_for_benchmarks,
  coalesce((CASE WHEN starts_with(coalesce(p.extra, ''), '{"_row":') THEN json_extract_string(p.extra, '$._row.hash_scope') WHEN json_type(p.extra, '$.hash_scope') IS NOT NULL THEN json_extract_string(p.extra, '$.hash_scope') WHEN NOT coalesce(json_contains(json_extract(p.extra, '$._absent'), '"hash_scope"'), false) THEN b.const_hash_scope END), 'file') AS dup_scope,
  (CASE WHEN starts_with(coalesce(p.extra, ''), '{"_row":') THEN json_extract_string(p.extra, '$._row.hashes.sha256') WHEN json_type(p.extra, '$.hashes.sha256') IS NOT NULL THEN json_extract_string(p.extra, '$.hashes.sha256') WHEN coalesce(json_contains(json_extract(p.extra, '$._hx'), '"sha256"'), false) THEN NULL ELSE lower(hex(p.sha256)) END) AS dup_sha256,
  (CASE WHEN starts_with(coalesce(p.extra, ''), '{"_row":') THEN json_extract_string(p.extra, '$._row.hashes.sha1') WHEN json_type(p.extra, '$.hashes.sha1') IS NOT NULL THEN json_extract_string(p.extra, '$.hashes.sha1') WHEN coalesce(json_contains(json_extract(p.extra, '$._hx'), '"sha1"'), false) THEN NULL ELSE lower(hex(p.sha1)) END) AS dup_sha1,
  (CASE WHEN starts_with(coalesce(p.extra, ''), '{"_row":') THEN json_extract_string(p.extra, '$._row.hashes.md5') WHEN json_type(p.extra, '$.hashes.md5') IS NOT NULL THEN json_extract_string(p.extra, '$.hashes.md5') WHEN coalesce(json_contains(json_extract(p.extra, '$._hx'), '"md5"'), false) THEN NULL ELSE lower(hex(p.md5)) END) AS dup_md5,
  CASE p.source WHEN 'stackexchange-dump' THEN nullif((CASE WHEN starts_with(coalesce(p.extra, ''), '{"_row":') THEN json_extract_string(p.extra, '$._row.source_meta.' || 'site') WHEN json_type(p.extra, '$.source_meta') IS NOT NULL THEN json_extract_string(p.extra, '$.source_meta.' || 'site') WHEN NOT coalesce(json_contains(json_extract(p.extra, '$._absent'), '"source_meta"'), false) THEN json_extract_string(b.const_source_meta, '$.' || 'site') END), '') END AS dup_unit,
  b.registry_order AS dup_ord,
  replace(regexp_extract(coalesce(p.batch, ''), '[0-9]{4}-?[0-9]{2}-?[0-9]{2}'), '-', '') AS dup_date,
  CASE WHEN p.source IN ('stackexchange-dump') THEN coalesce(nullif(replace(regexp_extract(coalesce(p.batch, ''), '[0-9]{4}-?[0-9]{2}-?[0-9]{2}'), '-', ''), ''), replace(regexp_extract(coalesce((CASE WHEN starts_with(coalesce(p.extra, ''), '{"_row":') THEN json_extract_string(p.extra, '$._row.source_meta.' || 'batch') WHEN json_type(p.extra, '$.source_meta') IS NOT NULL THEN json_extract_string(p.extra, '$.source_meta.' || 'batch') WHEN NOT coalesce(json_contains(json_extract(p.extra, '$._absent'), '"source_meta"'), false) THEN json_extract_string(b.const_source_meta, '$.' || 'batch') END), ''), '[0-9]{4}-?[0-9]{2}-?[0-9]{2}'), '-', '')) ELSE '' END AS dup_sdate
FROM p JOIN b ON b.source = p.source AND b.batch = p.batch
WHERE NOT EXISTS (SELECT 1 FROM o WHERE o.scope = 'row' AND o.hit_class IN ('benchmark_copy', 'task_file', 'data_address') AND o.source = p.source AND o.uri = p.uri AND o.range_offset IS NOT DISTINCT FROM p.range_offset AND o.member_path IS NOT DISTINCT FROM p.member_path)
  AND NOT EXISTS (SELECT 1 FROM o WHERE o.scope = 'container' AND o.hit_class IN ('benchmark_copy', 'task_file', 'data_address') AND o.source = p.source AND o.collection = split_part(p.collection, '@', 1))
  AND coalesce((SELECT bool_and(c.default_keep) FROM c WHERE c.scope = 'file' AND c.row_file = p.row_file), false) AND NOT EXISTS (SELECT 1 FROM c WHERE c.scope = 'container' AND NOT c.default_keep AND c.source = p.source AND c.collection = split_part(p.collection, '@', 1)))))))
) WHERE duplicate_reason IS NULL;
```

查询远程读取行表,而且只读它需要的列;把每个来源完整扫一遍要传输几 GB。
在第一条语句读目录的地方和 `p` 上加上 `WHERE source IN (...)` 可以保持很小;这时重复只在读到的行之间判定。
视图新增 training_tier 和 redistribution_tier(yes、conditional、no 或 unknown)、checked_for_benchmarks(该行与基准测试清单比对过、并且它的分组没有在等待裁定时为 true),以及 natural_key_conflict(自然键相同的其他行作为重复被去掉、保留了这一行这个按采集时间最新的版本时为 true;只出现在每个快照每个键只有一行之前写成的版本中)。

## 现成的查询

每个查询都在上面的 `selected` 视图上运行。

1. 只要可以用于训练的行(训练等级为 yes 或 conditional):

```sql
SELECT p.source, p.uri, p.size_bytes, p.training_tier FROM selected p
WHERE p.training_tier IN ('yes', 'conditional') LIMIT 20;
```

   `python tools/fetch.py --tier yes,conditional --limit 20 --out ./files`

2. 每个软件包只要最新版本。最新指最后发布的版本(按发布时间,所以后来为较旧分支发布的修复版也算最新);保留该版本的所有文件,没有版本或发布时间的行被去掉。软件包生态和所用的发布时间:

| 来源 | 发布时间 |
|---|---|
| pypi | `source_meta.upload_time` |
| npm | `source_meta.published` |
| crates-io | `source_meta.created_at` |
| cran | 无(快照只列出每个软件包的当前版本) |
| conda-forge-packages | `source_meta.timestamp` |
| ansible-galaxy-collections | `source_meta.published` |
| artifact-hub-helm-charts | `source_meta.created` |
| go-module-proxy-zips | `source_meta.index_timestamp` |
| hackage-packages | `source_meta.uploaded` |

   这个查询不排序的:

- debian-sources:各行没有发布时间,而 Debian 版本需要 dpkg 的排序规则,普通 SQL 没有;每个发行套件对每个源码包只列一个版本,所以改用 `source_meta.suite` 选择套件。
- nuget, rubygems:这些行还没有定义发布时间字段;每个版本都保留。

```sql
CREATE OR REPLACE VIEW latest_version AS
WITH v AS (
  SELECT p.*, concat_ws('/', p.collection, (CASE WHEN starts_with(coalesce(p.extra, ''), '{"_row":') THEN json_extract_string(p.extra, '$._row.source_meta.' || 'chart') WHEN json_type(p.extra, '$.source_meta') IS NOT NULL THEN json_extract_string(p.extra, '$.source_meta.' || 'chart') WHEN NOT coalesce(json_contains(json_extract(p.extra, '$._absent'), '"source_meta"'), false) THEN json_extract_string(b.const_source_meta, '$.' || 'chart') END)) AS package, (CASE WHEN starts_with(coalesce(p.extra, ''), '{"_row":') THEN json_extract_string(p.extra, '$._row.source_meta.' || 'version') WHEN json_type(p.extra, '$.source_meta') IS NOT NULL THEN json_extract_string(p.extra, '$.source_meta.' || 'version') WHEN NOT coalesce(json_contains(json_extract(p.extra, '$._absent'), '"source_meta"'), false) THEN json_extract_string(b.const_source_meta, '$.' || 'version') END) AS version,
    try_cast(CASE p.source WHEN 'pypi' THEN (CASE WHEN starts_with(coalesce(p.extra, ''), '{"_row":') THEN json_extract_string(p.extra, '$._row.source_meta.' || 'upload_time') WHEN json_type(p.extra, '$.source_meta') IS NOT NULL THEN json_extract_string(p.extra, '$.source_meta.' || 'upload_time') WHEN NOT coalesce(json_contains(json_extract(p.extra, '$._absent'), '"source_meta"'), false) THEN json_extract_string(b.const_source_meta, '$.' || 'upload_time') END) WHEN 'npm' THEN (CASE WHEN starts_with(coalesce(p.extra, ''), '{"_row":') THEN json_extract_string(p.extra, '$._row.source_meta.' || 'published') WHEN json_type(p.extra, '$.source_meta') IS NOT NULL THEN json_extract_string(p.extra, '$.source_meta.' || 'published') WHEN NOT coalesce(json_contains(json_extract(p.extra, '$._absent'), '"source_meta"'), false) THEN json_extract_string(b.const_source_meta, '$.' || 'published') END) WHEN 'crates-io' THEN (CASE WHEN starts_with(coalesce(p.extra, ''), '{"_row":') THEN json_extract_string(p.extra, '$._row.source_meta.' || 'created_at') WHEN json_type(p.extra, '$.source_meta') IS NOT NULL THEN json_extract_string(p.extra, '$.source_meta.' || 'created_at') WHEN NOT coalesce(json_contains(json_extract(p.extra, '$._absent'), '"source_meta"'), false) THEN json_extract_string(b.const_source_meta, '$.' || 'created_at') END) WHEN 'cran' THEN '1970-01-01T00:00:00Z' WHEN 'conda-forge-packages' THEN (CASE WHEN starts_with(coalesce(p.extra, ''), '{"_row":') THEN json_extract_string(p.extra, '$._row.source_meta.' || 'timestamp') WHEN json_type(p.extra, '$.source_meta') IS NOT NULL THEN json_extract_string(p.extra, '$.source_meta.' || 'timestamp') WHEN NOT coalesce(json_contains(json_extract(p.extra, '$._absent'), '"source_meta"'), false) THEN json_extract_string(b.const_source_meta, '$.' || 'timestamp') END) WHEN 'ansible-galaxy-collections' THEN (CASE WHEN starts_with(coalesce(p.extra, ''), '{"_row":') THEN json_extract_string(p.extra, '$._row.source_meta.' || 'published') WHEN json_type(p.extra, '$.source_meta') IS NOT NULL THEN json_extract_string(p.extra, '$.source_meta.' || 'published') WHEN NOT coalesce(json_contains(json_extract(p.extra, '$._absent'), '"source_meta"'), false) THEN json_extract_string(b.const_source_meta, '$.' || 'published') END) WHEN 'artifact-hub-helm-charts' THEN (CASE WHEN starts_with(coalesce(p.extra, ''), '{"_row":') THEN json_extract_string(p.extra, '$._row.source_meta.' || 'created') WHEN json_type(p.extra, '$.source_meta') IS NOT NULL THEN json_extract_string(p.extra, '$.source_meta.' || 'created') WHEN NOT coalesce(json_contains(json_extract(p.extra, '$._absent'), '"source_meta"'), false) THEN json_extract_string(b.const_source_meta, '$.' || 'created') END) WHEN 'go-module-proxy-zips' THEN (CASE WHEN starts_with(coalesce(p.extra, ''), '{"_row":') THEN json_extract_string(p.extra, '$._row.source_meta.' || 'index_timestamp') WHEN json_type(p.extra, '$.source_meta') IS NOT NULL THEN json_extract_string(p.extra, '$.source_meta.' || 'index_timestamp') WHEN NOT coalesce(json_contains(json_extract(p.extra, '$._absent'), '"source_meta"'), false) THEN json_extract_string(b.const_source_meta, '$.' || 'index_timestamp') END) WHEN 'hackage-packages' THEN (CASE WHEN starts_with(coalesce(p.extra, ''), '{"_row":') THEN json_extract_string(p.extra, '$._row.source_meta.' || 'uploaded') WHEN json_type(p.extra, '$.source_meta') IS NOT NULL THEN json_extract_string(p.extra, '$.source_meta.' || 'uploaded') WHEN NOT coalesce(json_contains(json_extract(p.extra, '$._absent'), '"source_meta"'), false) THEN json_extract_string(b.const_source_meta, '$.' || 'uploaded') END) END AS TIMESTAMPTZ) AS released
  FROM selected p JOIN b ON b.source = p.source AND b.batch = p.batch
  WHERE p.source IN ('pypi', 'npm', 'crates-io', 'cran', 'conda-forge-packages', 'ansible-galaxy-collections', 'artifact-hub-helm-charts', 'go-module-proxy-zips', 'hackage-packages')
), best AS (
  SELECT source, package, arg_max(version, released) AS version FROM (
    SELECT source, package, version, max(released) AS released FROM v
    WHERE version IS NOT NULL AND released IS NOT NULL GROUP BY ALL)
  GROUP BY ALL
)
SELECT v.* FROM v JOIN best ON best.source = v.source AND best.package = v.package AND best.version = v.version;
SELECT source, package, version, count(*) AS files FROM latest_version GROUP BY ALL ORDER BY 1, 2 LIMIT 20;
```

3. 只要不超过所在批次大小上限的行(meta/batches.parquet 中的 max_size_bytes,也就是 `tools/fetch.py` 默认使用的上限;大小未知的行保留,脚本下载它们时在同一上限处停止):

```sql
SELECT p.source, p.uri, p.size_bytes, b.max_size_bytes FROM selected p JOIN b ON b.source = p.source AND b.batch = p.batch
WHERE p.size_bytes IS NULL OR p.size_bytes <= b.max_size_bytes LIMIT 20;
```

   `python tools/fetch.py --limit 20 --out ./files`(超过上限的行记为 too_large,不下载)

## 示例

`meta/catalog.parquet` 每个来源一行。
它的列 `domain` 列出来源的主题代码:一个顶级代码(D1 到 D10)或它下面的叶子(如 D1.6),内容跨越许多主题时为 `multi`,或者 `unclassified`。
它的列 `form` 写明条目的形式(例如 `document-collections`)。
`meta/tags.parquet` 存放合集标签 `campaign:<name>`。

1. 主题为 D1 或它的叶子之一的来源的行,从小到大:

```sql
SELECT p.source, p.uri, p.size_bytes FROM selected p
WHERE p.source IN (SELECT source FROM (SELECT source, unnest(domain) AS code FROM read_parquet('hf://datasets/Battam/training-data-foundation/meta/catalog.parquet'))
                   WHERE code = 'D1' OR starts_with(code, 'D1.'))
ORDER BY p.size_bytes LIMIT 20;
```

   `python tools/fetch.py --domain D1 --limit 20 --out ./files`

2. 某一形式的来源中的 CSV 文件:

```sql
SELECT p.source, p.uri, p.size_bytes FROM selected p
WHERE lower(p.ext) = 'csv' AND p.source IN (SELECT source FROM read_parquet('hf://datasets/Battam/training-data-foundation/meta/catalog.parquet') WHERE form = 'document-collections')
LIMIT 20;
```

   `python tools/fetch.py --form document-collections --ext csv --limit 20 --out ./files`

3. 一个合集的行:

   `python tools/fetch.py --tag campaign:<name> --limit 20 --out ./files`

4. 某一领域和形式的每个来源各取三个单元,每个单元放在单独的文件夹里,按构建任务所需的结构摆放:

   `python tools/fetch.py --domain D3 --form spreadsheets --sample 3 --out ./data`

`python tools/fetch.py --print-sql ...` 打印脚本实际运行的查询,所以任何选择都可以在 DuckDB 中重复。
脚本把文件写在 `--out` 下:`<domain>/<source>/<unit folder>/...`(每个单元整体放在以它的 `unit_id` 命名的单独文件夹里;材料集的 README.md 和 LICENSE 放在旁边),`_meta/manifest.jsonl` 每个文件一行(source、path、url、sha256、bytes、license、unit_id 等),还有 `_meta/sizes.tsv`,以及 `_meta/fetch_manifest.jsonl`,每个所选的行一行。
它按该行声明的大小和该行带有的哈希校验每次下载,而这些是哪些哈希取决于行的种类:

- 整个文件和字节范围:md5、sha1 和 sha256(`extra` 带有 sha512 或 git blob sha1 时也校验;单段上传的 S3 ETag 算作 md5)。它们不比较 crc32。
- 存档成员(zip、其他软件包、7z):大小、crc32、md5、sha1 和 sha256;zip 成员还按存档中央目录中的 CRC32 校验。它们不比较 sha512 和 git blob sha1。
- WARC 和 ARC 记录:载荷的大小,以及载荷的 md5、sha1 和 sha256。
- gzip 成员:gzip 尾部中的 CRC32 和长度,以及该行有的 crc32、md5、sha1 和 sha256。
- 没有哈希的行只按大小校验,标为 `rolling` 的行可以与索引不同而不算失败(见下文)。

加上 `--check-content` 时,它还会在清单字段 `content_check` 中标出难以使用的下载(扫描的 PDF、存成文件的错误页、与内容不符的扩展名);这需要 `file` 命令和 `pypdf` 包(脚本的依赖之一),它们会在你的机器上解析下载的文件(来自互联网的文件),缺少工具的检查会跳过,并在那里写明。

## 卡片各字段可信到什么程度

卡片的每个字段都有 `evidence.<field>.fill`,说明它的值从哪里来:

- `auto`:构建卡片时由程序从来源的行和采集头信息算出(`checked_at` 是那一天)。卡片与数据分开构建,不会随每次上传重建。
- `judgment`:从下载并读过的样本文件读出,附 `basis`(为什么)和 `files`(哪些文件)。有的带有 `second_judge`,即独立的第二次判读。读过样本后更正的 `auto` 值也记为 `judgment`,原因写在 `basis` 中。
- `derived`:基于同一张卡片其他字段的固定规则。
- `unfilled`:还没有依据。该字段特意留空;不要把空字段读作否或没有。

`audit.status` 为 `draft` 的卡片还没有作为整体评审过。
依赖一张卡片之前,先把 `snapshot.rev` 与你正在读的提交比较,并把 `size.files` 与 meta/coverage.json 中该来源的计数比较。

| 字段组 | 字段 | 通常的填写方式 | 可信到什么程度 |
|---|---|---|---|
| 快照 | `snapshot.rev`, `snapshot.rev_at`, `snapshot.at` | auto | 卡片描述的是哪份数据:`snapshot.rev` 是构建卡片时该来源最新数据文件所在的提交。如果它比你读到的提交旧,卡片上的每个计数都已过时。 |
| 计数和文件类型 | `size.files`, `size.bytes`, `unit.batches`, `form.by_ext`, `form.size_quantiles`, `form.over_cap`, `form.date_years` | auto | 对 `snapshot.rev` 时已有的行准确。要当前的数字,用 meta/coverage.json 或查询各行;README 的合计每次上传都重新计算。 |
| 许可证 | `provenance.licence`, `provenance.licence_tiers`, `provenance.spdx_top` | auto | 抄自来源自己的许可证声明和各行的许可证列。tools/fetch.py 不读卡片:它使用许可证列和 meta/batches.parquet。`provenance.licence_sample_check` 是从样本作出的判读。 |
| 基准测试重叠 | `risk.contamination`, `risk.overlap_check` | auto,来源没有扫描时为 unfilled | 构建卡片时重叠扫描的结果。默认筛选不使用它;meta/bench_overlap.parquet 和 meta/bench_checked.parquet 更新,以它们为准。 |
| 文件是什么 | `unit.pointer_level`, `unit.usable_unit`, `form.artifact`, `form.source_origin`, `form.parse_cost`, `form.parse_quirks`, `structure.*`, `ships.*`, `subject.*` | judgment 或 unfilled | 从下载的文件样本读出;`files` 列出它们。像 `ships.reference_solution.share` 这样的占比是读过的 n 个文件中的 k 个。把它当作对样本的描述。 |
| 从样本读出的风险 | `risk.pii`, `risk.pii_evidence`, `risk.malware` | judgment 或 unfilled | 空值表示还没有人看过,不表示该来源是干净的。卡片文本把电子邮件地址和电话号码显示为 `[withheld]`,但用空格分隔、没有加号的十位数字(如 555 123 4567)不会被当作电话号码,因为它与计数无法区分。 |
| 访问 | `access.credential`, `access.range_supported`, `access.drift` | judgment 或 unfilled | 一行是否需要登录在该行的 `access.needs_auth` 中(见 README),不在这里。 |
| 规则 | `class`, `unit.state`, `risk.ship_bytes` | derived | `class` 是基于 `ships.*` 和 `structure` 的规则,`unit.state` 跟随 `unit.pointer_level`,`risk.ship_bytes` 等于再分发等级。好坏取决于它们读取的字段。 |
| 已停用 | `access.reachable.index_flag` | auto | 已停用:它曾统计一台机器(现已停用)能否访问这些文件;现在总是 `(none)`,将在下一个卡片版本中移除。 |

## 从合集标签重建一个批次

合集发布在仓库 `Battam/training-data-foundation` 中,连同 `tools/to_pool.py`;下面的命令读取那个仓库,并使用其中的工具。

合集是为一个任务池一起挑选的一组行。
它的行带有标签 `campaign:<name>` 和批次名 `<name>`,并在 `source_meta` 中记录每个文件在任务池中的去处(领域、路径、单元)。
它的小文件(README、LICENSE 以及为软件包编写的文件)放在 `campaign_files/<name>/` 下;它们的行用相对 uri 指向那里,`tools/fetch.py` 在与各表相同的提交上读取它们。
其他所有行都指向上游文件。

两条命令重建该批次。
固定提交,以便以后运行得到同样的行:

```
python tools/fetch.py --data hf://datasets/Battam/training-data-foundation --tag campaign:<name> --all --revision <commit> --out ./fetched
python tools/to_pool.py ./fetched --out ./pools --name <batch-folder>
```

`--revision <commit>` 在该提交上读取各表。
同样的固定也可以写在根路径中:`--data hf://datasets/Battam/training-data-foundation@<commit>`。

`--all` 保留合集中基准测试标准保留的每一行:这些行是为任务池挑选的,默认配置的其他标准会去掉其中一部分(例如大于 20 MB 的行)。
与基准测试相符的行和还没有与基准测试清单比对过的行仍然留在外面,除非加上 `--allow-benchmark` 或 `--allow-not-compared`。
`tools/fetch.py` 已经写出文件,每个单元一个文件夹(`<domain>/<source>/<unit folder>/...`,还有 `_meta/manifest.jsonl` 和 `_meta/sizes.tsv`),把每行的任务池字段复制进 `_meta/fetch_manifest.jsonl`,并写出 `_meta/fetch_run.json`,记录仓库、提交和它的参数。
`tools/to_pool.py`(只用 Python 标准库,与 `tools/transform.py` 放在一起)补上下载工具不做的事:它取出需要 `transform` 步骤的单元,解开标为 `expand` 的单元,检查每个来源都有 README.md 和 LICENSE,写出 `<batch-folder>/<domain>/<source>/<path>`,还有 `_meta/manifest.jsonl`、`_meta/sizes.tsv` 和 `_meta/delivery.json`。
有一行没有下载时,它什么也不写。

有些上游文件会原地变化(实时端点)。
它们的行标为 `rolling`:大小或 sha256 与索引不同不算错误,清单用 `differs_from_index` 记下实际下载的字节数、sha256 和日期。
其他每一行都必须与索引完全一致。

上游存放在存档或压缩文件中的单元,它的行带有 `transform` 步骤:`unzip:<member>`、`untar:<member>`、`bunzip2`、`gunzip`、`unxz`、`unxxd`、`uudecode`、`uncompress` 和 `gzip`(级别 9,修改时间为 0,不含文件名,所以在每台机器上输出都相同)。
从存档中只取出指定的成员,而且它必须是普通文件;链接和会离开输出文件夹的名称都会被拒绝。
`unxxd` 把 `xxd` 或 `xxd -a` 写出的十六进制转储变回字节(每行 16 字节,两两成组,`*` 行代表若干行零字节),拒绝其他任何格式。
`uudecode` 解码第一行 `begin <mode> <name>` 与它的 `end` 行之间的内容,从不把那个名称用作路径,并拒绝没有 `begin` 行、有第二个 `begin` 行或有无法解码的行的文件。
`uncompress` 解压 Unix `compress` 的 `.Z` 文件(LZW,魔数 `1f 9d`,码宽从 9 位到最多 16 位,按 `compress` 写入的方式每八个一组读取),拒绝错误的魔数、9 到 16 之外的最大码宽,以及还不在表中的码。
`unxz`、`untar`、`unxxd`、`uudecode` 和 `uncompress` 的输出在 256,000,000 字节处截止(稀疏 tar 成员按完整大小计)。
`tools/fetch.py` 下载并校验上游原件;`tools/to_pool.py` 运行这些步骤,并按索引中记录的 sha256(`unit_sha256`)校验结果,最后一步是 `gzip` 时(它的字节取决于 zlib 的构建),则按 `content_sha256`,即该步骤之前字节的哈希校验。