Add quick tokenizer judging columns

README.md

@@ -23,8 +23,14 @@ filter, and compare the tokenizers without navigating contributor folders.
 - `author`: contributor's exact GitHub username, resolved from the source repository's pull-request history.
 - `size`: tokenizer vocabulary size.
 - `name`: original filename.
+- `quick_status`: whether the artifact is ready to load or needs custom conversion.
+- `hf_loadable`: whether it loads directly with `tokenizers.Tokenizer.from_file(...)`.
 - `format`: normalized artifact-format classification.
 - `model_type`: tokenizer model type reported by the source.
+- `merge_count`: number of BPE merge rules when available.
+- `normalizer`, `pre_tokenizer`, `decoder`: quick configuration summary.
+- `unk_token`, `added_tokens_count`: special-token readiness indicators.
+- `reported_metrics`: evaluation numbers reported by the author, encoded as JSON.
 - `metadata`: normalized metadata encoded as a JSON string.
 - `tokenizer_json`: complete, lossless original JSON file contents.
 - `source_path`: original path in the source repository.
@@ -42,3 +48,8 @@ filter, and compare the tokenizers without navigating contributor folders.
 All source files were parsed as valid JSON. A file being valid JSON does not
 imply it implements the Hugging Face Tokenizers serialization schema; check the
 `format` column before loading `tokenizer_json`.
+
+Reported metrics were produced with different texts and procedures, so they are
+useful for inspecting an individual submission but not for ranking authors. A
+fair quality ranking requires running every compatible tokenizer against the
+same held-out Polish evaluation corpus.

build_parquet.py

@@ -46,6 +46,42 @@ def extract_metadata(document: dict) -> dict:
     return metadata
 
 
+def component_name(value) -> str:
+    if value is None:
+        return "none"
+    if isinstance(value, dict):
+        return str(value.get("type", "configured"))
+    return str(value)
+
+
+def merge_count(document: dict) -> int | None:
+    model = document.get("model")
+    candidates = []
+    if isinstance(model, dict):
+        candidates.append(model.get("merges"))
+    candidates.extend((document.get("merges"), document.get("reguly_merge")))
+    for value in candidates:
+        if isinstance(value, (list, dict)):
+            return len(value)
+    for key in ("liczba_regul_merge", "n_merges"):
+        if isinstance(document.get(key), int):
+            return document[key]
+    return None
+
+
+def extract_reported_metrics(document: dict) -> dict:
+    markers = ("eval", "metr", "fert", "znaki_na_token", "tokens_per_word", "sweep", "compression")
+    metrics = {}
+    for key, value in document.items():
+        if any(marker in key.lower() for marker in markers):
+            metrics[key] = value
+    if isinstance(document.get("meta"), dict):
+        for key, value in document["meta"].items():
+            if any(marker in key.lower() for marker in markers):
+                metrics[f"meta.{key}"] = value
+    return metrics
+
+
 def main() -> None:
     parser = argparse.ArgumentParser()
     parser.add_argument("--source-root", type=Path, default=Path("."))
@@ -59,13 +95,25 @@ def main() -> None:
             source_path = item["source_path"]
             raw_json = (args.source_root / source_path).read_text(encoding="utf-8")
             document = json.loads(raw_json)
+            model = document.get("model") if isinstance(document.get("model"), dict) else {}
+            metrics = extract_reported_metrics(document)
+            hf_loadable = item["format"] == "hf_tokenizers"
             rows.append(
                 {
                     "author": GITHUB_AUTHORS[item["contributor"]],
                     "size": int(item["vocab_size"]),
                     "name": Path(source_path).name,
+                    "quick_status": "ready_hf_tokenizers" if hf_loadable else "custom_conversion_required",
+                    "hf_loadable": hf_loadable,
                     "format": item["format"],
                     "model_type": item["model_type"],
+                    "merge_count": merge_count(document),
+                    "normalizer": component_name(document.get("normalizer")),
+                    "pre_tokenizer": component_name(document.get("pre_tokenizer")),
+                    "decoder": component_name(document.get("decoder")),
+                    "unk_token": str(model.get("unk_token") or ""),
+                    "added_tokens_count": len(document.get("added_tokens", [])),
+                    "reported_metrics": json.dumps(metrics, ensure_ascii=False, sort_keys=True),
                     "metadata": json.dumps(
                         extract_metadata(document), ensure_ascii=False, sort_keys=True
                     ),
@@ -82,8 +130,17 @@ def main() -> None:
             ("author", pa.string()),
             ("size", pa.int64()),
             ("name", pa.string()),
+            ("quick_status", pa.string()),
+            ("hf_loadable", pa.bool_()),
             ("format", pa.string()),
             ("model_type", pa.string()),
+            ("merge_count", pa.int64()),
+            ("normalizer", pa.string()),
+            ("pre_tokenizer", pa.string()),
+            ("decoder", pa.string()),
+            ("unk_token", pa.string()),
+            ("added_tokens_count", pa.int64()),
+            ("reported_metrics", pa.string()),
             ("metadata", pa.string()),
             ("tokenizer_json", pa.large_string()),
             ("source_path", pa.string()),

data/train-00000-of-00001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:41aaae73e4a924dad689ea6bf87142abb937157b90781205b228d98a2abde415
-size 16487708
+oid sha256:2763c94cfaeb582062ad428d600015d9e6f0646a61081a190a8505e3a2243bf0
+size 16491254