[Back to README.md](../README.md) # Fields English | [简体中文](fields.zh.md) ## Repository layout - `data/`: the rows, packed into a few large files `rows-.parquet` (about 100 MB to 1 GB each) sorted by source and unit: a large source has files of its own, small sources share one; the columns `source` and `batch` say which source and batch a row belongs to; one row per key (source, uri, range_offset, member_path): a corrected row replaces the old one, whose file is written again without it. The column `data_files` of `meta/catalog.parquet` names the files that hold each source's rows: read those, not a listing of `data/`. - [`meta/catalog.parquet`](../meta/catalog.parquet): one row per source: its kind (corpus or material set), what it is, size, types, license tier and login (subset `catalog`). - [`meta/preview.parquet`](../meta/preview.parquet): 10 rows of every source, with the columns of `data/` (subset `preview`); one source is read whole from the data files its row of `meta/catalog.parquet` names in `data_files`, one read per file and no listing of `data/`. - [`meta/sizes.parquet`](../meta/sizes.parquet): measured sizes: a sample of rows of every data file, each with its recorded size, the size measured by download, by reading a member out of its archive or by a request for its first byte, and whether it matched (its columns: section Measured sizes below). - [`meta/size_figures.json`](../meta/size_figures.json): the figures of this release, each total computed once: the counts and the size figures of every level (the whole index, the two layers, each collection, each main domain of the corpora and each source): recorded size, deduplicated size, the check against `meta/sizes.parquet` and the estimate for the rows without a recorded size, with its range; and the facts and the release days the dataset card's tables give. The dataset card, these pages and the data page read their numbers from it. - [`meta/stage_figures.json`](../meta/stage_figures.json): the counts per training stage of the stage table `catalog/stages.yaml` in the code repository (post-training in material sets, units and the upstream sources they come from; mid-training and pre-training in corpus rows and bytes), evaluated over `meta/stage_fields.parquet`, with the version of the table they used; each stage with its funnel, its counts before the rules every stage shares and after each of them, in their order (benchmark, not compared, personal data, duplicate). - [`meta/translations.parquet`](../meta/translations.parquet): the Chinese version of every name and description the Chinese pages show (the collections, each source's title, description and summary, the training stages): one row per English text, keyed by its sha256, translated once by a language model. - [`meta/vocabulary.json`](../meta/vocabulary.json): the codes of `domain` with their names and the ids of `form`, each with one sentence saying what it means; the two layers, the collections, and the Chinese term table every Chinese page uses (`terms`). - [`meta/sources.json`](../meta/sources.json): per-source details: description, license per batch, layout, counts by type and size. - [`meta/coverage.json`](../meta/coverage.json): totals by license tier, source, unit, size and tag; `projections.license_unknown`: the license writings whose tier is unknown, a source's (level `source`) or one its rows declare of their own (level `row`), each with its reason code (`unrecognized`: the expression does not parse or names a license in neither table), sources and rows, for one reading of each by a person; `projections.leaves`: for every leaf of the domain grid, the benchmark tasks (a task of one benchmark version, one row of `catalog/bench_leaves.tsv` in the code repository) and benchmarks labeled with it and the usable material sets and their units there. - [`meta/batches.parquet`](../meta/batches.parquet): one row per batch with its license tiers. - [`meta/tags.parquet`](../meta/tags.parquet): which rows belong to which campaign tag (`campaign:`, a batch of a collection's material sets). - [`meta/bench_overlap.parquet`](../meta/bench_overlap.parquet): rows that match public benchmark tasks, in the data files compared with the key version named in `meta/projection.json` (bench_keys); [for-agents.md](for-agents.md) says how many sources were compared. - [`meta/bench_checked.parquet`](../meta/bench_checked.parquet): the data files compared with the benchmark list; a row whose data file is not listed was not compared. - [`meta/benchmarks.parquet`](../meta/benchmarks.parquet): the benchmark list: one row per benchmark entry, public, gated or private, with its version, weight, license, page, task count, the indexes it is a member of and its tasks counted per leaf of the domain grid; no task text. - [`meta/attribution.parquet`](../meta/attribution.parquet): who published each file of a material set and under which license: one row per source, publisher, license and license URL, with its number of files; a file whose row names none takes its source's license and license URL (`meta/sources.json`). - [`meta/size_caps.json`](../meta/size_caps.json): the overall size cap that `tools/fetch.py` applies when downloading. - [`meta/croissant.json`](../meta/croissant.json): Croissant metadata (JSON-LD) for the catalog and every source. - [`meta/not_included.parquet`](../meta/not_included.parquet): units that are not included, each with the requirement it does not meet (see [access.md](access.md)). - `cards/`: one card per source: `.yaml` with every field and its evidence, `.md` to read. - `campaign_files/`: files stored in this repository for the material sets whose rows point here (the README.md and LICENSE the index writes for each, files written for a package). - `tools/`: `fetch.py` selects, downloads and verifies files and lays them out for building tasks (see [for-agents.md](for-agents.md)); it writes a unit stored inside a container as the unit itself, checked against the unit's hash; `to_pool.py` unpacks units marked expand and writes a collection's pool with its delivery record. - `docs/`: `selecting.md`: fields, the default filter and examples; `sources.md`, `fields.md`, `for-agents.md` and `access.md`: the details the dataset card links to; each page has its Chinese version `.zh.md` beside it; `banner.svg` and `banner.zh.svg`: the banners of the English and the Chinese card; `figures/`: the card's figures, drawn at every release from `meta/size_figures.json`, each light and dark (for the Hub's two themes) and wide and narrow, with `.zh.svg` for the Chinese card. - [`CHANGELOG.md`](../CHANGELOG.md): what each release changed. - [`NOTICE`](../NOTICE): the attribution of ScanCode LicenseDB (CC-BY-4.0), whose license categories the license tiers and reason codes of this dataset are computed from. ## Row fields Row columns of the data files under `data/` (the same in every source; the column `data_files` of `meta/catalog.parquet` names the files of each source): | Column | Type | Meaning | |---|---|---| | `source` | text | Name of the source; the same as the folder under data/. | | `batch` | text | Batch the row was published in; its license is batches[].license in meta/sources.json. | | `collection` | text | Grouping inside the source as the source names it (a project, a crawl, a list), when it has one. | | `ext` | text | File extension taken from the upstream file name, lower case; empty when the name has none. | | `uri` | text | Address to download the item from (https, s3, git, rsync or hf); rows stored in this repository give a path under campaign_files/. | | `range_offset` | integer | When the item is one record inside a bigger file (a web archive record, a byte range): where it starts, in bytes. | | `range_length` | integer | Length in bytes of that record; empty for whole files. | | `member_path` | text | When the item is a file inside an archive: its path inside the archive. | | `parent_pointer_id` | text | Identifier of the archive or container the item is part of, when it is a member. | | `zip_local_header_offset` | integer | For a member of a zip archive: offset of its local header, so it can be read with one range request. | | `zip_compression_method` | integer | For a member of a zip archive: its compression method (0 stored, 8 deflate). | | `zip_compressed_size` | integer | For a member of a zip archive: its compressed size in bytes. | | `size_bytes` | integer | Size in bytes of the item as delivered; empty when the source does not publish it. | | `media_type` | text | Media type of the item when known. | | `sha256` | 32 bytes | SHA-256 of the item, 32 bytes (hex-encode to compare); empty when not known. | | `sha1` | 20 bytes | SHA-1 of the item when the source publishes it, 20 bytes. | | `md5` | 16 bytes | MD5 of the item when the source publishes it, 16 bytes. | | `crc32` | 4 bytes | CRC-32 of the item when the source publishes it, 4 bytes. | | `origin_url` | text | Page or record the item was found on, when it differs from uri. | | `origin_time` | text | Time the source gives for the item (for a web archive, the capture time), as given. | | `truncated` | text | Set when the content behind the pointer is cut short at the source (for example a truncated API body); empty otherwise. | | `license_spdx` | text | The row's own license as an SPDX expression; empty when the row takes its batch license. | | `license_training_ok` | text | The row's own training tier (yes, conditional, no); empty when it takes its batch tier. | | `license_redistribution_ok` | text | The row's own redistribution tier (yes, conditional, no); empty when it takes its batch tier. | | `license_notes` | text | Notes on the row's own license. | | `sensitive` | text | health or minors when the item is about health or about minors; empty otherwise. | | `collected_at` | text | When the row was collected (UTC, YYYY-MM-DDTHH:MM:SSZ): the time the collector recorded when it wrote the row's shard (for a material set, when the collector emitted the row's file), kept when the row's file is written again; of the rows under one key the one collected last is the one a snapshot holds. Empty when no time was recorded (rows written before the column was added, or collected before the collector recorded one); such a row ranks by the start of its batch's date in UTC, and below every row with a time when its batch name has no date. | | `extra` | text | JSON with the row's remaining fields (for example its own access.needs_auth or source-specific metadata). The rows of a material set carry their place in a task pool in extra.source_meta: unit_group (the key `unit_id` of the row's unit, shared by its files), pool_path, pool_leaf and pool_fields; `tools/fetch.py` writes them into its manifest. The rows of the material sets admitted from the search's candidates carry their labels in extra.source_meta.labels: language (ISO 639; zxx for no linguistic content), pool_status (accepted, pending or pool_rejected, with pool_reject_category and pool_reject_reason), robots, terms, and a unit's own domain and leaf where its source has another. | ## Catalog fields Columns of `meta/catalog.parquet` (one row per source). `domain` and `form` come from the catalog rules of the pipeline repository (`catalog/rules.tsv`, else the source's registration in `meta/sources.json`), as their rows below say. `kind` says whether the source is a corpus (`corpus`) or a material set (`material_set`), computed from its entry in `meta/sources.json` by the rule its row below gives; select one kind with `WHERE kind = 'corpus'` or `WHERE kind = 'material_set'`, since the units of a material set and the rows of a corpus are never added together. `collection` gives the collection of a material set, the code of a line of the pipeline's `admit_collections.tsv` (A, B, C, G, GT, HW, M, MD, ML, OP, S, SC, SW; their names are in `meta/vocabulary.json`), found from the campaign batches of the material set and kept only when the material set meets what the collection's definition admits (`admits` in `catalog/domains.yaml`); for a corpus it is the collection that lists the corpus under `corpora` in `catalog/domains.yaml` (a corpus holding that collection's kind of material, still counted in rows and never added to its material sets), and empty otherwise. Select one collection with `WHERE collection = 'A'`, or take its material sets with `tools/fetch.py --tag campaign:` for each campaign the collection lists in `meta/vocabulary.json` (a corpus it lists, with `--source`). Every other column is projected from the card field named next to it; `cards/.yaml` holds the evidence for each value. Card field names follow the corpus card format where the meaning is the same; the third column gives the corpus card field for each column, so the two formats can be matched. Cards use `card_version` 5. | Column | Field in cards/.yaml | Corpus card field | How it is filled | Values | Meaning | |---|---|---|---|---|---| | `source` | `source` | `source` | counted from the index | text | Name of the source; key of the catalog and the name of its folder under data/. | | `title` | `title` | none (this format only) | declared by the source, reviewed | text | Display name of the source. | | `status` | `status` | `status` | fixed rule, reviewed | `ok`, `flagged` | Processing status of the card of the source: ok, or flagged with reasons; a source whose upstream serves none of its sampled rows read (fetch level none) is flagged too, with that reading as a reason, and is not usable as it is. | | `status_reasons` | `status_reasons` | `status_reasons` | fixed rule, reviewed | list of text | Why the card is flagged; empty when ok. | | `description` | `description` | none (this format only) | declared by the source, reviewed | text | First sentences of the source's own description. | | `kind` | none: counted from the source's entry in meta/sources.json | none (this format only) | fixed rule | `corpus`, `material_set` | Kind of the source: corpus (raw; plural corpora), one whole upstream that a collector keeps reading in bulk, counted in rows, each pointing to one file or record; or material_set (task-ready), the units admitted from one source for building tasks, counted in units (`unit_id`). A source is a material_set when it holds rows of a collection (its entry in meta/sources.json names a campaign or collections that extend it) or it has fewer units than files; every other source is a corpus. The same rule as the data page. | | `collection` | none: counted from the source's entry in meta/sources.json | none (this format only) | fixed rule | text | For a material set, the code of its collection (catalog/domains.yaml collections, one per line of admit_collections.tsv; every code with its name is in meta/vocabulary.json), found from its campaign batches and kept only when the material set meets what the collection's definition admits (its admits in catalog/domains.yaml, such as spreadsheet unit files for A); for a corpus, the collection that lists it under corpora in catalog/domains.yaml (a corpus holding that collection's kind of material), else empty. Material sets are task material; corpora are a second layer, never added to it. | | `domain` | none: from the catalog rules (see its meaning) | none (this format only) | fixed rule | list of text | Domain codes of the source, heaviest first: a top-level domain code such as D1 or one of its leaves such as D1.6, or multi (the content spans many domains) or unclassified. Taken from the source's default row in catalog/rules.tsv of the pipeline repository, else from the domain of the source's registration (its entry in meta/sources.json), else unclassified; the codes are described in catalog/domains.yaml of the pipeline repository. A batch with its own row in rules.tsv keeps it for its rows; this column gives the source's default. | | `form` | none: from the catalog rules (see its meaning) | none (this format only) | fixed rule | text | Form of the source's material, one id such as test-suites or tickets: from the same row of catalog/rules.tsv of the pipeline repository, else from the source's registration; empty when neither gives one. The forms are described in catalog/domains.yaml of the pipeline repository. | | `license` | `license.tier` | `license.tier` | fixed rule, declared by the source, reviewed | `permissive`, `share-alike`, `nc-research`, `internal-only`, `unknown`, `no-training`, `mixed` | License: spdx (SPDX expression), tier (see the tier legend), reason (the reason code: the ScanCode LicenseDB category of the license that decided the tier, in lower case with hyphens, a code of its overlay such as us-pd, or the source's own terms: terms-of-use, robots, all-rights-reserved; unrecognized when the expression does not parse or names a license in neither table), note (first sentences of the source's license statement; the full statement is on the card), ship (whether the files may be shipped). | | `contamination` | none: computed from meta/bench_overlap.parquet and meta/bench_checked.parquet by the default profile of tools/fetch.py | `label.contamination.level` | counted from the index | `none`, `benchmark_copy`, `task_file`, `data_address`, `not scanned` | Benchmark overlap, by the rule of the default profile of `tools/fetch.py` over `meta/bench_overlap.parquet` and `meta/bench_checked.parquet`: level `none` when every data file of the source is compared and kept by default and the profile removes none of its rows; the hit class with the most removed rows when it removes some, with the benchmarks they match (benchmark), `row` or `container` (scope) and the number of rows and whole groupings (the row column `collection`) removed (evidence); `not scanned` otherwise. | | `pii` | `risk.pii` | `label.pii.level` | fixed rule, judged from samples, reviewed | `none_known`, `suspected`, `present` | Personal information read from samples: level and evidence; empty until judged. | | `files` | `size.files` | `size.files` | counted from the index | integer | Number of files: the rows (pointers) of the source in this release, each one file or record; for a material set, the files of its units and the README.md and LICENSE the index writes for it. A corpus is counted in these rows. | | `units` | none: counted from the source's entry in meta/sources.json | none (this format only) | counted from the index | integer | Number of units of a material set, the distinct `unit_id` values: the unit_group values its rows share (a test case, one workbook, one package; the README.md and LICENSE of the material set are no unit). A corpus is counted in rows, and this column gives the same number as files. Empty for a material set whose units are not counted yet. | | `publishers` | none: counted from the rows of the release's data files | none (this format only) | counted from the index | integer | Number of publishers of a material set: the distinct publisher names in the pool_fields of all its rows (extra.source_meta.pool_fields, the unit's line of the pool manifest), never its upstream addresses. Empty for a corpus and for a material set whose rows carry none. | | `license_counts` | none: counted from the rows of the release's data files | none (this format only) | counted from the index | list of objects | The files of a material set by kind of file and license: one item per kind (upstream, its upstream files; index, the files the index wrote for it under campaign_files/, its README.md, LICENSE and package files), license (spdx) and the permits for training and redistribution (training_ok, redistribution_ok: yes, conditional, no or unknown), with its number of files (files); a row without its own license takes its batch license. The items of a material set add up to its files. Empty for a corpus. | | `language` | none: counted from the source's entry in meta/sources.json | none (this format only) | counted from the index | text | Language of the rows: the language codes in their label (extra.source_meta.language, else extra.source_meta.labels.language; the label the default profile of tools/fetch.py filters on, keeping English, zxx and rows without a code), with shares when mixed; `not recorded` for rows whose label holds no code. | | `bytes` | `size.bytes` | `size.bytes` | counted from the index | integer | Referenced size: the sum of size_bytes over the rows that have a size, once per row (content that several rows point to counts once per row); empty when no row has one. | | `distinct_bytes` | none: counted from the source's entry in meta/sources.json | none (this format only) | counted from the index | integer | Distinct content: bytes minus the sizes of the source's rows that repeat another row's content (the same hash, one copy kept in the first source by registry order); empty when no row has a size or the release records no such sizes. | | `size_check` | none: computed from the readings in meta/sizes.parquet | none (this format only) | counted from the index | object of integers | The check of the recorded sizes: rows, the rows of the source read in `meta/sizes.parquet`; compared, those that compared a size or hash (match, size_mismatch, hash_mismatch), over which the check's share is taken; and how many of them have each status (match, size_mismatch, hash_mismatch, unreachable, gone, needs_auth, no_length, error). | | `fetch_check` | none: computed from the readings in meta/sizes.parquet | none (this format only) | counted from the index | object | Whether the upstream still serves the source's files, from the same readings in `meta/sizes.parquet`: rows, its sampled rows read; fetched, those that fetched and matched their recorded size and hash (status match; bytes that are not the recorded file, such as an HTML page in place of a workbook, differ in size or sha256 and count as not fetched); read_at, the day of its latest reading (UTC); level, `all` when every row read fetched, `some`, `none` when no row read did, `not read` without a reading. The source stays listed whatever its level; the data page, its card and docs/sources.md show the reading, and `tools/fetch.py` names the source before it fetches when a reading taken on or after the day of the release it reads found rows that did not fetch. | | `unsized_rows` | none: counted from the source's entry in meta/sources.json | none (this format only) | counted from the index | integer | Number of rows without a recorded size. | | `unsized_estimate` | none: computed from the readings in meta/sizes.parquet | none (this format only) | counted from the index | object of integers | The estimated size of the rows without a recorded size: bytes, unsized_rows times the mean measured size of such rows read (status match), low and high, its 95% BCa bootstrap range (scipy.stats.bootstrap), and readings, the rows read it rests on; empty when fewer than 10 such rows were read. | | `unit` | `unit.units` | none (this format only) | counted from the index | text | What one row points at (file, archive member, web archive record, byte range, API response), with shares when mixed; for a material set, its units and its files, the same counts as the columns units and files. | | `top_types` | `form.by_ext` | none (this format only) | counted from the index | list of text | The most common file extensions, by rows. | | `needs_auth` | `access.needs_auth` | none (this format only) | counted from the index | text | Whether a download needs a login: no, a value naming what is needed, or mixed. | | `data_files` | none: listed from the columns source and batch of the rows of the release's data files | none (this format only) | counted from the index | list of text | The repository paths of the data files that hold the source's rows, sorted. Read the source's rows from exactly these files (as `tools/fetch.py` does): one read of this catalog, then one read per file, and no listing of `data/`, whose requests count against the Hub's rate limits. | | `batch_files` | none: listed from the columns source and batch of the rows of the release's data files | none (this format only) | counted from the index | list of objects | Each batch of the source with a data file that holds rows of it (batch, file), sorted by batch and file; a batch held by several files has one item per file. `tools/fetch.py --tag` reads only the files of the tagged batches. Each item also gives the source's first and last row in that file (first, last, counted from 0), so a reader of one source reads that row range alone. | | `released_in` | none: taken from the release's set of records | none (this format only) | counted from the index | text | The release tag of the release whose record of the source its rows come from: each source is built and checked in a run of its own, and a release takes its newest record that passed every check. | | `held_back` | none: taken from the release's set of records | none (this format only) | counted from the index | text | Why a newer batch of the source is held back, in the words of the release notes (the checks its record failed, or a finding of the release); the source keeps its newest version that passed every check until a newer batch passes. | ## Benchmark overlap classes Every row compared with the benchmark list that matches a file or an address of a public benchmark task, or whose address is in a GitHub repository the benchmark list names or in a fork of one, is listed in `meta/bench_overlap.parquet` with one class in `hit_class`. The overlap scan of the pipeline repository (`02_scripts/bench_overlap.py` with `02_scripts/tb_overlap.py`) assigns the class, and this table is written from that code, its thresholds and lists included. The default profile of `tools/fetch.py` removes the rows of `benchmark_copy`, `task_file`, `data_address` and keeps the rows of every other class, which are recorded only. Every key is exact: the hashes of a whole file's bytes, a normalized address, an image reference, and for a zip member its size with its CRC32; so a file converted to another format (another file type, encoding or compression) has other bytes and is found only by an address it keeps. | Class | Default profile | What it means | How it is decided | Keys compared | A file converted to another format | |---|---|---|---|---|---| | `benchmark_copy` | removed | The row's container (a dataset, repository or package: the first two segments of its pointer id) is a copy of a benchmark: it holds the files of at least 5 different tasks of one benchmark, or it is derived from a benchmark. | Raised from task_file: its hits are counted per source, container and benchmark (a file that holds several tasks counts each task), and at 5 or more distinct tasks every hit row of that container except a weak match becomes benchmark_copy; a container the scan's name rulings name as derived from a benchmark is taken whole. The containers of web archive and crawl sources are never raised. | Those of task_file; a derived container by its name. | Not found by its content, as for task_file; a derived container is found by its name whatever its files' format. | | `task_file` | removed | The row is the same file as a file of a benchmark task, a file that is not trivial (over 64 bytes, not generic text, not a package), or it is the task's own evaluation image named in the task's metadata. | A hash hit that none of trivial_small, generic_text and third_party_package takes; an image hit whose image the task's metadata names and that is not an official library image (`docker.io/library/`). | sha256, sha1 and md5 of the whole file (sha256 alone for a file known only by its Git LFS pointer); for an image, its normalized reference. | Not found: other bytes give other hashes. | | `data_address` | removed | The row's address is one a benchmark task names for its data: a download or reference address in a task's files, the upstream pull request or issue a task is built from, an address of a task's corpus, or an address an evaluation set listing gives; or the row's address is in a GitHub repository the benchmark list names, or in a fork of one (forks of forks included). | An address hit that reference_or_namespace and build_dependency do not take; an address from the upstream pull request or issue, corpus or evaluation set listing fields of a task always; and always a row whose `uri`, `alt_uris` or `origin.url` is in such a repository or fork (an address of `github.com`, `raw.githubusercontent.com`, `codeload.github.com`, `media.githubusercontent.com/media`, `api.github.com/repos` followed by its owner and name), once for each benchmark that names the repository. The forks are listed through GitHub's REST API at every release. | The address, normalized (`tb_overlap.norm_url`); for a repository, the owner and name in the address, compared without case. | Found while the row keeps the same address: the address is compared, not the bytes. | | `third_party_package` | kept | A public software package that a task bundles: the same release file. | A hash hit whose task file is a package release file (`.whl`, `.egg`, `.conda`, `.tar.bz2`, `.jar`, `.gem`, `.crate`, `.nupkg`, `.deb`, `.rpm`) or lies under a `wheels/` folder. | sha256, sha1 and md5 of the whole file. | Not found: other bytes give other hashes. | | `build_dependency` | kept | The download address of something a task is built with: a package address in a lock or requirements file, or a download from a package registry. | An address hit whose task file name matches `(^\|[-_.])lock([-_.]\|$)\|^requirements.*\.txt$\|^pnpm-lock\.yaml$\|^yarn\.lock$\|^go\.sum$`, or whose host is a package registry (`registry.npmjs.org`, `registry.yarnpkg.com`, `files.pythonhosted.org`, `static.crates.io`, `proxy.golang.org`, `repo.maven.apache.org`, `repo1.maven.org`, `rubygems.org`). | The address, normalized (`tb_overlap.norm_url`). | Found while the row keeps the same address. | | `base_image` | kept | A container image a task is built on, of the same name and tag. | An image hit from a Dockerfile `FROM` or a compose file's `image`, or an official library image that a task's metadata names. | The image reference (name and tag), normalized. | Compared by name and tag only, so the format of its files does not count. | | `generic_text` | kept | Generic text that many repositories carry the same copy of: a license, a `.gitignore` and the like. | A hash hit whose task file name matches `^(license\|licence\|copying\|notice\|authors)([._-].*)?$\|^\.(gitignore\|gitkeep\|keep\|dockerignore\|gitattributes)$` or starts with license, whose task file lies under a `LICENSES/` folder, or whose own file has such a name. | sha256, sha1 and md5 of the whole file. | Not found: other bytes give other hashes. | | `trivial_small` | kept | A very small file (at most 64 bytes) with trivial content, whose same checksum does not show the same origin. | A hash hit on a task file of at most 64 bytes, before any other rule of a hash hit. | sha256, sha1 and md5 of the whole file. | Not found: other bytes give other hashes. | | `reference_or_namespace` | kept | A namespace or literature reference address, not a download. | An address hit on one of `arxiv.org`, `creativecommons.org`, `doi.org`, `dx.doi.org`, `gnu.org`, `json-schema.org`, `ogp.me`, `opensource.org`, `purl.org`, `rdfs.org`, `schema.org`, `w3.org`, `xmlns.com` or a subdomain of one, or on a path that starts with `/licenses/`. | The address, normalized (`tb_overlap.norm_url`). | Found while the row keeps the same address. | | `weak_size_crc32` | kept | A weak match, listed apart from the classes above: a zip member with the same size and CRC32 as a task file. It is never removed and never raised to benchmark_copy. | A zip member over 64 bytes whose size and CRC32, read from the zip's directory without fetching the member, equal a task file's. | Size with CRC32. | Not found: other bytes give another CRC32 and size. | ## Measured sizes Columns of `meta/sizes.parquet` (one row per measured row). The sizes the rows record are mostly what the upstream services reported, and some rows record none. This file holds measurements of a sample of them: a fixed set of rows of every data file, drawn on a hash of the row's address and the file's sha256, so the same file gives the same rows. A sampled row up to 64 MiB is downloaded, checked against its recorded size and every recorded hash, then deleted; for a larger row, or one without a recorded size, the server is asked for the file's length without its body: one `GET` of the first byte (`Range: bytes=0-0`), and the complete length of its `Content-Range` (or its `Content-Length` when the server sends the whole file, whose body is not read); an empty file has no first byte and answers `416` with its length 0 in `Content-Range`. A row whose answer gives no length, or that has no address to ask, is `no_length`. A failure that says nothing about the row (HTTP 429 or 5xx, or no answer at all) is measured again a day later, and after several in a row less and less often. A row whose upstream answers HTTP 404 or 410 is `gone`: the upstream no longer has the file. A row's file in the index repository (`campaign_files/...`) is read from the commit measured. A data file that is not measured yet has no rows here. | Column | Type | Values | Meaning | |---|---|---|---| | `source` | text | | Name of the source of the measured row. | | `batch` | text | | Batch of the measured row. | | `file` | text | | Path of the row's data file in this repository (a Parquet file under data/; meta/catalog.parquet names each source's). | | `file_sha256` | text | | sha256 of that data file; a file with other bytes is measured anew. | | `row_key` | text | | Address of the row: uri, then @range_offset when it is a byte range, then !/member_path when it is a member of a container. | | `recorded_size_bytes` | integer | | size_bytes of the row as published; empty when the row records none. | | `measured_size_bytes` | integer | | Size measured now: the bytes downloaded (fetched), or the member's own bytes read out of its archive (member), or the length the server answered (info; range and content_length in older readings), or the bytes of its answer counted (counted, in older readings); empty when none was learned. | | `method` | text | `member`, `fetched`, `info`, `range`, `content_length`, `counted` | How it was measured: member (a member of an archive, read out of it and checked against its own size and CRC32 by the public fetch tool), fetched (downloaded whole and checked; always for content taken from an API answer, a page region or a registry manifest), info (the length the server answers without the body: the complete length of the Content-Range of a GET of the first byte, or that GET's Content-Length when the server sends the whole file, whose body is not read; an empty file, which has no first byte, answers 416 with its length 0 in Content-Range). Readings taken before info have: range (complete length of the Content-Range of a Range: bytes=0-0 request), content_length (Content-Length of a server that sent the whole file), counted (the bytes of an answer without a complete length, counted up to 64 MiB). | | `hash_checked` | true or false | | Whether a recorded hash was compared with the downloaded bytes. | | `hash_ok` | true or false | | Whether the hashes compared matched; empty when none was compared. | | `status` | text | `match`, `size_mismatch`, `hash_mismatch`, `unreachable`, `gone`, `needs_auth`, `no_length`, `error` | match (the measured size equals the recorded one, or the row records none and a size was measured), size_mismatch, hash_mismatch, unreachable (no address answered), gone (the upstream no longer has the file: HTTP 404 or 410, or the source marks it as deleted), needs_auth (a login or an access request is needed), no_length (no length was learned: the server's answers give none, the row has no address to ask, or a member of an archive is longer than 64 MiB), error (another failure; reason says which). | | `http_status` | integer | | HTTP status of the last answer, where there was one. | | `reason` | text | | What went wrong, in words; empty for a match. | | `measured_at` | time (UTC) | | When the row was measured. |