docs/retrieval.md

Retrieving and verifying files

The catalog holds no file content. To use a file, download it from the address in its pointer and check it against the size and hashes the pointer gives. The fields are described in fields.md.

Steps

1. Choose an address: uri, or one from alt_uris, which serve the same bytes. s3:// addresses usually have a public https address in alt_uris. hf://datasets/<repo>@<revision>/<path> stands for https://huggingface.co/datasets/<repo>/resolve/<revision>/<path>.
2. If access.needs_auth says that a login, a guestbook or a form is needed, follow the source's procedure first.
3. If the pointer has range, request only those bytes with the HTTP header Range: bytes=<offset>-<offset + length - 1>. The file is that byte range of uri, for example one record inside a WARC file, and size_bytes equals length.
4. Compare the number of bytes with size_bytes, unless it is null (the source does not publish the size) or hash_scope is registry_manifest (below).
5. Compute the hashes named in hashes and compare every value; hash_scope says what they cover (below). Treat a mismatch as a failure; do not substitute another file.
6. If hashes is empty (hash_source is computed_on_fetch), the source publishes no hash: compute your own after download and keep it with the file.

fetch_selected.py, next to this page, follows these steps for every pointer of a selection whose hashes cover the downloaded bytes (hash_scope of file), byte ranges included; how to run it is in selecting.md.

What the hashes cover (hash_scope)

• file (the default when the field is absent): the bytes you downloaded, that is the whole file, or the byte range when the pointer has range.
• http_payload: the range is one gzip-compressed WARC record. Decompress it, remove the WARC and HTTP headers, undo chunked transfer encoding, and hash the HTTP response body. size_bytes stays the compressed length of the record.
• api_body: uri returns JSON from an API. Hash the UTF-8 bytes of the field named in source_meta.api_body_field (a dotted path in which numbers index lists; items.0.body when absent), not the whole response. Non-string values are written with json.dumps(value, ensure_ascii=False) before hashing. The path $ names the whole response body as returned (after gzip decoding), hashed without parsing and reserializing it. When source_meta.api_body_decode is base64, the field holds the file content as base64 text: decode it and compare size and hashes on the decoded bytes, which are the file.
• html_region: uri is an HTML page with parts that can differ between requests (comments, ratings, text shown only to some readers). Hash only the stable region named in source_meta.html_region, not the whole page; size_bytes is the size of that region. For ctftime_page, working on the page bytes: take the span from the first <div class="page-header"> up to (not including) the first <h3>Comments</h3> after it, split it on newline bytes, and append the lines after that point that contain MDConvert.render(; drop lines that contain ctftimecanary (any letter case) but not MDConvert.render(, and lines that are empty or only ASCII whitespace; strip trailing ASCII whitespace from each line; join with a newline byte and add one final newline. A page without both markers fails.
• registry_manifest: uri is a container image manifest in a container registry, addressed by its digest. Get a pull token first (the batch notes say how), request uri with that token and an Accept header listing the manifest types, and hash the response bytes; the sha256 equals the digest. size_bytes is not the length of the manifest: it is the compressed size of the image layers, which equals the sum of layers[].size inside the manifest.
• zip_member_deflate: the range is the compressed data of one member of a ZIP archive (the bytes after its local header). Inflate it as raw DEFLATE data (no zlib or gzip header). The result is the file: its size is payload_size_bytes, its CRC-32 is source_meta.crc32 (8 lowercase hex digits), and hashes cover it. size_bytes stays the compressed length.

Files inside archives

A pointer with parent_pointer_id and member_path is a file inside an archive that has its own pointer: retrieve and verify the archive, then extract member_path. When it also has zip_entry, uri is the zip archive and the file can be retrieved alone: request the 30-byte local file header at local_header_offset, read the file name length (bytes 26-27) and extra field length (bytes 28-29), request compressed_size bytes right after them, decompress (compression_method 0 is stored, 8 is raw deflate), and compare the length with size_bytes and the CRC32 with hashes.crc32.

Source notes and the manifests themselves

Each collection.json adds notes for its source under fetch and notes. Its shards list gives the sha256 of every part file of the batch, so the downloaded manifests can be checked too.