jaro 0.1.15__tar.gz

jaro-0.1.15/.gitignore

@@ -0,0 +1,7 @@
+.venv/
+__pycache__/
+*.egg-info/
+.mypy_cache/
+.pytest_cache/
+dist/
+.ruff_cache/

jaro-0.1.15/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.5
+Name: jaro
+Version: 0.1.15
+Summary: JARO text and binary data format (pure Python)
+Project-URL: Homepage, https://jaro.raczylo.com
+Project-URL: Repository, https://github.com/lukaszraczylo/jaro
+License-Expression: MIT
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: mypy==2.4.0; extra == 'dev'
+Requires-Dist: pytest==9.1.1; extra == 'dev'
+Requires-Dist: pyyaml==6.0.3; extra == 'dev'
+Requires-Dist: types-pyyaml==6.0.12.20260906; extra == 'dev'
+Provides-Extra: native
+Requires-Dist: jaro-native; extra == 'native'
+Description-Content-Type: text/markdown
+
+# jaro (Python)
+
+Pure-Python codec for JARO, a JSON-model data format with a text form and a binary form. The format is specified in [`../SPEC.md`](../SPEC.md). Python 3.10 or later, no runtime dependencies, fully typed.
+
+## Install
+
+```
+pip install .            # from this directory
+pip install -e '.[dev]'  # tests, mypy and the YAML benchmark
+```
+
+## API
+
+```python
+import jaro
+
+jaro.dumps({"a": [1, 2.5, None]})            # 'a:[1 2.5 ~]'
+jaro.loads("a:[1 2.5 ~]")                    # {'a': [1, 2.5, None]}
+jaro.dumps_binary(value, dedup=False)        # bytes
+jaro.loads_binary(data)                      # value
+```
+
+- `dumps(value, *, dedup=False) -> str` and `loads(text: str | bytes) -> Any`.
+- `dumps_binary(value, *, dedup=False) -> bytes` and `loads_binary(data: bytes) -> Any`.
+- `dedup=True` replaces repeated sub-trees (24 bytes or more of text) with anchors and references.
+- `JaroError` subclasses `ValueError`. Its `offset` attribute is the byte offset in the input, or `None` for encoder errors.
+
+Mapping: `None`, `bool`, `int` (int64), `float` (finite), `str`, `list` and `dict` with `str` keys. Encoders sort keys. Decoders reject duplicate keys. Integral floats below 2^53 decode as `int`, and zero is always `0`. Tuples, sets and bytes are rejected.
+
+Supported: text and binary forms, anchors, spreads, comments, tables (plain, sparse with `^`, keyed `{|k| ...}`, nested columns `key{sub}`). Not supported: schema validation, the `Parse`/`Doc` arena, HTTP middleware and zstd.
+
+## Conformance
+
+`tests/test_conformance.py` runs `../conformance/vectors.json`: every `text`, `binary`, `badText`, `badTextHex` and `badBinaryHex` case, a round trip of every `trees` entry, and byte-exact parity with the Go reference for every vector that has a tree (text, binary and binary with dedup). The parity allowlists in that file are empty.
+
+```
+pytest -q
+mypy --strict src
+```
+
+## Limits
+
+- Nesting depth 512, reference expansion 2^24 nodes, binary counts checked against the remaining input and a node budget of 4M plus 32 per input byte. Codecs use about one Python frame per nesting level, so depth 512 works under the default recursion limit. A `RecursionError` from a very deep caller stack is reported as `JaroError`.
+- Invalid UTF-8 is rejected on decode. A lone surrogate in a `str` is rejected on encode.
+- Binary floats that are NaN or infinite are rejected on decode.
+
+## Benchmark
+
+```
+python bench/bench.py                 # corpus: $JARO_CORPUS, default ../../corpus
+```
+
+It prints encode and decode milliseconds and output bytes against `json` and PyYAML (libyaml loader when available), and writes `bench/results.json`.
+
+## Optional native decoder
+
+`loads_binary` uses the `jaro_native` Rust extension when it is installed (`pip install jaro-native`, built from `native-py/`). Without it, the pure Python decoder runs. Set `JARO_PURE=1` to force the pure decoder. `jaro.binary.NATIVE` reports which one is active. `jaro.binary.loads_binary_py` always runs the pure decoder.

jaro-0.1.15/README.md

@@ -0,0 +1,57 @@
+# jaro (Python)
+
+Pure-Python codec for JARO, a JSON-model data format with a text form and a binary form. The format is specified in [`../SPEC.md`](../SPEC.md). Python 3.10 or later, no runtime dependencies, fully typed.
+
+## Install
+
+```
+pip install .            # from this directory
+pip install -e '.[dev]'  # tests, mypy and the YAML benchmark
+```
+
+## API
+
+```python
+import jaro
+
+jaro.dumps({"a": [1, 2.5, None]})            # 'a:[1 2.5 ~]'
+jaro.loads("a:[1 2.5 ~]")                    # {'a': [1, 2.5, None]}
+jaro.dumps_binary(value, dedup=False)        # bytes
+jaro.loads_binary(data)                      # value
+```
+
+- `dumps(value, *, dedup=False) -> str` and `loads(text: str | bytes) -> Any`.
+- `dumps_binary(value, *, dedup=False) -> bytes` and `loads_binary(data: bytes) -> Any`.
+- `dedup=True` replaces repeated sub-trees (24 bytes or more of text) with anchors and references.
+- `JaroError` subclasses `ValueError`. Its `offset` attribute is the byte offset in the input, or `None` for encoder errors.
+
+Mapping: `None`, `bool`, `int` (int64), `float` (finite), `str`, `list` and `dict` with `str` keys. Encoders sort keys. Decoders reject duplicate keys. Integral floats below 2^53 decode as `int`, and zero is always `0`. Tuples, sets and bytes are rejected.
+
+Supported: text and binary forms, anchors, spreads, comments, tables (plain, sparse with `^`, keyed `{|k| ...}`, nested columns `key{sub}`). Not supported: schema validation, the `Parse`/`Doc` arena, HTTP middleware and zstd.
+
+## Conformance
+
+`tests/test_conformance.py` runs `../conformance/vectors.json`: every `text`, `binary`, `badText`, `badTextHex` and `badBinaryHex` case, a round trip of every `trees` entry, and byte-exact parity with the Go reference for every vector that has a tree (text, binary and binary with dedup). The parity allowlists in that file are empty.
+
+```
+pytest -q
+mypy --strict src
+```
+
+## Limits
+
+- Nesting depth 512, reference expansion 2^24 nodes, binary counts checked against the remaining input and a node budget of 4M plus 32 per input byte. Codecs use about one Python frame per nesting level, so depth 512 works under the default recursion limit. A `RecursionError` from a very deep caller stack is reported as `JaroError`.
+- Invalid UTF-8 is rejected on decode. A lone surrogate in a `str` is rejected on encode.
+- Binary floats that are NaN or infinite are rejected on decode.
+
+## Benchmark
+
+```
+python bench/bench.py                 # corpus: $JARO_CORPUS, default ../../corpus
+```
+
+It prints encode and decode milliseconds and output bytes against `json` and PyYAML (libyaml loader when available), and writes `bench/results.json`.
+
+## Optional native decoder
+
+`loads_binary` uses the `jaro_native` Rust extension when it is installed (`pip install jaro-native`, built from `native-py/`). Without it, the pure Python decoder runs. Set `JARO_PURE=1` to force the pure decoder. `jaro.binary.NATIVE` reports which one is active. `jaro.binary.loads_binary_py` always runs the pure decoder.

jaro-0.1.15/bench/bench.py

@@ -0,0 +1,147 @@
+"""Time JARO against json and PyYAML on a directory of real JSON files.
+
+Usage: python bench/bench.py [--budget SECONDS] [--yaml auto|c|pure]
+The corpus is $JARO_CORPUS, default ../../corpus relative to py/.
+Writes bench/results.json as {file: {format: {enc_ms, dec_ms, bytes}}}.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import time
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+PY_ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(PY_ROOT / "src"))
+sys.path.insert(0, str(PY_ROOT / "tests"))
+
+from conftest import same  # noqa: E402
+
+import jaro  # noqa: E402
+
+MIN_RUNS = 3
+MAX_RUNS = 200
+
+
+def best_ms(fn: Callable[[], Any], budget: float) -> float:
+    """Return the fastest run in ms: at least MIN_RUNS runs, then stop after budget seconds."""
+    best = float("inf")
+    start = time.perf_counter()
+    runs = 0
+    while runs < MIN_RUNS or (runs < MAX_RUNS and time.perf_counter() - start < budget):
+        t0 = time.perf_counter()
+        fn()
+        best = min(best, time.perf_counter() - t0)
+        runs += 1
+    return best * 1000
+
+
+def yaml_codec(
+    choice: str,
+) -> tuple[str, Callable[[bytes], Any], Callable[[Any], str]] | None:
+    try:
+        import yaml  # type: ignore[import-untyped,unused-ignore]
+    except ImportError:
+        return None
+    c_ok = bool(getattr(yaml, "__with_libyaml__", False))
+    if choice == "c" and not c_ok:
+        raise SystemExit("libyaml is not available in this PyYAML build")
+    if (choice in ("auto", "c")) and c_ok:
+        return (
+            "PyYAML CSafeLoader/CSafeDumper (libyaml)",
+            lambda b: yaml.load(b, Loader=yaml.CSafeLoader),
+            lambda v: yaml.dump(v, Dumper=yaml.CSafeDumper, allow_unicode=True),
+        )
+    return (
+        "PyYAML safe_load/safe_dump (pure Python)",
+        yaml.safe_load,
+        lambda v: yaml.safe_dump(v, allow_unicode=True),
+    )
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument(
+        "--budget",
+        type=float,
+        default=2.0,
+        help="seconds per cell after the first 3 runs",
+    )
+    ap.add_argument("--yaml", choices=("auto", "c", "pure"), default="auto")
+    args = ap.parse_args()
+    corpus = Path(
+        os.environ.get("JARO_CORPUS") or PY_ROOT / ".." / ".." / "corpus"
+    ).resolve()
+    files = sorted(corpus.glob("*.json"))
+    if not files:
+        raise SystemExit(f"no .json files in {corpus}")
+    ycodec = yaml_codec(args.yaml)
+    print(f"corpus: {corpus}")
+    print(
+        f"yaml:   {ycodec[0] if ycodec else 'not installed (pip install pyyaml); YAML skipped'}"
+    )
+    print(
+        f"python: {sys.version.split()[0]}  budget: {args.budget}s/cell, min {MIN_RUNS} runs, min of runs reported\n"
+    )
+
+    results: dict[str, dict[str, dict[str, float | int]]] = {}
+    for path in files:
+        raw = path.read_bytes()
+        tree = json.loads(raw)
+        text = jaro.dumps(tree)
+        blob = jaro.dumps_binary(tree)
+        if not same(jaro.loads(text), tree) or not same(jaro.loads_binary(blob), tree):
+            raise SystemExit(f"{path.name}: round trip changed the tree")
+        text_b = text.encode("utf-8")
+        compact = json.dumps(tree, separators=(",", ":"), ensure_ascii=False)
+        cells: dict[str, tuple[Callable[[], Any], Callable[[], Any], int]] = {
+            "json": (
+                lambda: json.dumps(tree, separators=(",", ":"), ensure_ascii=False),
+                lambda: json.loads(raw),
+                len(compact.encode("utf-8")),
+            ),
+            "jaro": (lambda: jaro.dumps(tree), lambda: jaro.loads(text_b), len(text_b)),
+            "jaro-bin": (
+                lambda: jaro.dumps_binary(tree),
+                lambda: jaro.loads_binary(blob),
+                len(blob),
+            ),
+        }
+        if ycodec is not None:
+            ytext = ycodec[2](tree).encode("utf-8")
+            cells["yaml"] = (
+                lambda: ycodec[2](tree),
+                lambda: ycodec[1](ytext),
+                len(ytext),
+            )
+        out: dict[str, dict[str, float | int]] = {}
+        print(f"{path.name}  ({len(raw):,} B source)")
+        print(f"  {'format':<9}{'enc ms':>11}{'dec ms':>11}{'bytes':>12}{'vs json':>9}")
+        for name in ("json", "yaml", "jaro", "jaro-bin"):
+            if name not in cells:
+                continue
+            enc, dec, size = cells[name]
+            out[name] = {
+                "enc_ms": round(best_ms(enc, args.budget), 4),
+                "dec_ms": round(best_ms(dec, args.budget), 4),
+                "bytes": size,
+            }
+            ratio = size / cells["json"][2]
+            print(
+                f"  {name:<9}{out[name]['enc_ms']:>11.3f}{out[name]['dec_ms']:>11.3f}{size:>12,}{ratio:>8.0%}"
+            )
+        results[path.name] = out
+        print()
+    (PY_ROOT / "bench" / "results.json").write_text(
+        json.dumps(results, indent=2) + "\n", "utf-8"
+    )
+    print(f"wrote {PY_ROOT / 'bench' / 'results.json'}")
+
+
+if __name__ == "__main__":
+    main()

jaro-0.1.15/bench/decode_baseline.json

@@ -0,0 +1,14 @@
+{
+ "canada/bin": 8.939991798251867,
+ "canada/text": 30.79489601077512,
+ "citm_catalog/bin": 11.073729256168008,
+ "citm_catalog/text": 18.012027683046956,
+ "github_issues/bin": 3.9196314666276937,
+ "github_issues/text": 8.651388828487447,
+ "npm_express/bin": 18.71837497067948,
+ "npm_express/text": 20.96664602868259,
+ "recipe_book/bin": 0.2983134450210679,
+ "recipe_book/text": 0.4587311326209807,
+ "twitter/bin": 6.971232144029012,
+ "twitter/text": 8.118465154742202
+}

jaro-0.1.15/bench/decode_gm.py

@@ -0,0 +1,60 @@
+"""Geometric-mean decode metric: mean over 12 cells of time / baseline time (lower is better).
+
+Usage: python bench/decode_gm.py [--runs N] [--write-baseline] [--table]
+Each cell is the per-cell minimum over N passes of decode_metric.min_ms. Prints one number
+(the geometric mean ratio) and, on stderr, the worst cell regression. --write-baseline stores
+the cell times in bench/decode_baseline.json.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import decode_metric as dm  # noqa: E402
+
+BASELINE = Path(__file__).resolve().parent / "decode_baseline.json"
+
+
+def measure(runs: int) -> dict[str, float]:
+    cells: dict[str, float] = {}
+    for _ in range(runs):
+        for p in sorted(dm.CORPUS.glob("*.json")):
+            v = json.loads(p.read_text(encoding="utf-8"))
+            text = dm.jaro.dumps(v)
+            blob = dm.jaro.dumps_binary(v)
+            for kind, fn in (
+                ("text", lambda: dm.jaro.loads(text)),
+                ("bin", lambda: dm.jaro.loads_binary(blob)),
+            ):
+                key = f"{p.stem}/{kind}"
+                cells[key] = min(cells.get(key, math.inf), dm.min_ms(fn))
+    return cells
+
+
+def main() -> None:
+    runs = int(sys.argv[sys.argv.index("--runs") + 1]) if "--runs" in sys.argv else 1
+    cells = measure(runs)
+    if "--json" in sys.argv:
+        print(json.dumps(cells))
+        return
+    if "--write-baseline" in sys.argv:
+        BASELINE.write_text(json.dumps(cells, indent=1, sort_keys=True) + "\n")
+        print(f"wrote {BASELINE}")
+        return
+    base: dict[str, float] = json.loads(BASELINE.read_text())
+    ratios = {k: cells[k] / base[k] for k in base}
+    if "--table" in sys.argv:
+        for k, r in ratios.items():
+            print(f"{k:22s} {cells[k]:9.3f} ms  ratio {r:.3f}", file=sys.stderr)
+    worst = max(ratios, key=lambda k: ratios[k])
+    print(f"worst {worst} {ratios[worst]:.3f}", file=sys.stderr)
+    print(f"{math.exp(sum(map(math.log, ratios.values())) / len(ratios)):.4f}")
+
+
+if __name__ == "__main__":
+    main()

jaro-0.1.15/bench/decode_metric.py

@@ -0,0 +1,68 @@
+"""Decode metric: sum over the corpus files of the min decode ms, text loads + binary loads_binary.
+
+Usage: python bench/decode_metric.py [--table]
+Prints one number (ms, lower is better). gc is disabled around each timed loop here only,
+to cut noise; the library is untouched. --table also prints per-file numbers on stderr.
+"""
+
+from __future__ import annotations
+
+import gc
+import json
+import os
+import sys
+import time
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+PY_ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, os.environ.get("JARO_SRC", str(PY_ROOT / "src")))
+
+import jaro  # noqa: E402
+
+CORPUS = Path(os.environ.get("JARO_CORPUS", PY_ROOT.parent.parent / "corpus"))
+RUNS = 9
+TARGET_S = 0.05
+
+
+def min_ms(fn: Callable[[], Any]) -> float:
+    fn()
+    t0 = time.perf_counter()
+    fn()
+    one = max(time.perf_counter() - t0, 1e-6)
+    iters = max(1, round(TARGET_S / one))
+    best = float("inf")
+    for _ in range(RUNS):
+        gc.collect()
+        gc.disable()
+        try:
+            t0 = time.perf_counter()
+            for _ in range(iters):
+                fn()
+            dt = (time.perf_counter() - t0) / iters
+        finally:
+            gc.enable()
+        best = min(best, dt)
+    return best * 1000.0
+
+
+def main() -> None:
+    total = 0.0
+    rows = []
+    for p in sorted(CORPUS.glob("*.json")):
+        v = json.loads(p.read_text(encoding="utf-8"))
+        text = jaro.dumps(v)
+        blob = jaro.dumps_binary(v)
+        t = min_ms(lambda: jaro.loads(text))
+        b = min_ms(lambda: jaro.loads_binary(blob))
+        rows.append((p.stem, t, b))
+        total += t + b
+    if "--table" in sys.argv:
+        for name, t, b in rows:
+            print(f"{name:15s} text {t:9.3f}  bin {b:9.3f}", file=sys.stderr)
+    print(f"{total:.3f}")
+
+
+if __name__ == "__main__":
+    main()

jaro-0.1.15/bench/decode_ratio.py

@@ -0,0 +1,107 @@
+"""Ratio metric: JARO decode time / json.loads time per cell, geometric mean over 12 cells.
+
+Usage: python bench/decode_ratio.py [--rounds N] [--table] [--write-baseline]
+Each cell alternates rounds of the JARO decode and json.loads on the same file in one process and
+keeps the minimum of each, so machine noise cancels. gc is disabled inside the timed loops only.
+"""
+
+from __future__ import annotations
+
+import gc
+import json
+import math
+import os
+import sys
+import time
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+PY_ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, os.environ.get("JARO_SRC", str(PY_ROOT / "src")))
+
+import jaro  # noqa: E402
+
+CORPUS = Path(os.environ.get("JARO_CORPUS", PY_ROOT.parent.parent / "corpus"))
+BASELINE = Path(__file__).resolve().parent / "ratio_baseline.json"
+TARGET_S = 0.04
+
+
+def timed(fn: Callable[[], Any], iters: int) -> float:
+    gc.collect()
+    gc.disable()
+    try:
+        t0 = time.perf_counter()
+        for _ in range(iters):
+            fn()
+        return (time.perf_counter() - t0) / iters
+    finally:
+        gc.enable()
+
+
+def pair(
+    a: Callable[[], Any], b: Callable[[], Any], rounds: int
+) -> tuple[float, float]:
+    a()
+    b()
+    t0 = time.perf_counter()
+    a()
+    one = max(time.perf_counter() - t0, 1e-6)
+    ia = max(1, round(TARGET_S / one))
+    t0 = time.perf_counter()
+    b()
+    ib = max(1, round(TARGET_S / max(time.perf_counter() - t0, 1e-6)))
+    best_a = best_b = math.inf
+    for _ in range(rounds):
+        best_a = min(best_a, timed(a, ia))
+        best_b = min(best_b, timed(b, ib))
+    return best_a, best_b
+
+
+def measure(rounds: int) -> dict[str, float]:
+    ratios: dict[str, float] = {}
+    for p in sorted(CORPUS.glob("*.json")):
+        raw = p.read_text(encoding="utf-8")
+        v = json.loads(raw)
+        text = jaro.dumps(v)
+        blob = jaro.dumps_binary(v)
+        for kind, fn in (
+            ("text", lambda: jaro.loads(text)),
+            ("bin", lambda: jaro.loads_binary(blob)),
+        ):
+            a, b = pair(fn, lambda: json.loads(raw), rounds)
+            ratios[f"{p.stem}/{kind}"] = a / b
+    return ratios
+
+
+def geomean(r: dict[str, float]) -> float:
+    return math.exp(sum(map(math.log, r.values())) / len(r))
+
+
+def main() -> None:
+    rounds = (
+        int(sys.argv[sys.argv.index("--rounds") + 1]) if "--rounds" in sys.argv else 7
+    )
+    ratios = measure(rounds)
+    if "--write-baseline" in sys.argv:
+        BASELINE.write_text(json.dumps(ratios, indent=1, sort_keys=True) + "\n")
+        print(f"wrote {BASELINE}  geomean {geomean(ratios):.4f}")
+        return
+    base: dict[str, float] = (
+        json.loads(BASELINE.read_text()) if BASELINE.exists() else {}
+    )
+    if "--table" in sys.argv:
+        for k, r in ratios.items():
+            extra = f"  vs baseline {r / base[k]:.3f}" if k in base else ""
+            print(f"{k:22s} ratio {r:.3f}{extra}", file=sys.stderr)
+    if base:
+        worst = max(ratios, key=lambda k: ratios[k] / base[k])
+        print(
+            f"worst vs baseline {worst} {ratios[worst] / base[worst]:.3f}; geomean vs baseline {geomean(ratios) / geomean(base):.4f}",
+            file=sys.stderr,
+        )
+    print(f"{geomean(ratios):.4f}")
+
+
+if __name__ == "__main__":
+    main()

jaro-0.1.15/bench/ratio_baseline.json

@@ -0,0 +1,14 @@
+{
+ "canada/bin": 0.5654798992407275,
+ "canada/text": 1.9396151069347145,
+ "citm_catalog/bin": 2.3570592953758154,
+ "citm_catalog/text": 3.8092739782226865,
+ "github_issues/bin": 2.1009248801303415,
+ "github_issues/text": 4.144482715105189,
+ "npm_express/bin": 4.808100671740912,
+ "npm_express/text": 6.340230721931914,
+ "recipe_book/bin": 4.7041712924118295,
+ "recipe_book/text": 7.219384139072654,
+ "twitter/bin": 2.844153703222558,
+ "twitter/text": 4.151948224942099
+}

jaro-0.1.15/bench/results.json

@@ -0,0 +1,134 @@
+{
+  "canada.json": {
+    "json": {
+      "enc_ms": 27.091,
+      "dec_ms": 16.2067,
+      "bytes": 2090234
+    },
+    "yaml": {
+      "enc_ms": 247.8492,
+      "dec_ms": 305.3995,
+      "bytes": 3089399
+    },
+    "jaro": {
+      "enc_ms": 81.4531,
+      "dec_ms": 24.2975,
+      "bytes": 2090208
+    },
+    "jaro-bin": {
+      "enc_ms": 44.9303,
+      "dec_ms": 9.9295,
+      "bytes": 1112072
+    }
+  },
+  "citm_catalog.json": {
+    "json": {
+      "enc_ms": 2.1183,
+      "dec_ms": 4.627,
+      "bytes": 500299
+    },
+    "yaml": {
+      "enc_ms": 78.7743,
+      "dec_ms": 112.1735,
+      "bytes": 588331
+    },
+    "jaro": {
+      "enc_ms": 10.5187,
+      "dec_ms": 14.7006,
+      "bytes": 228077
+    },
+    "jaro-bin": {
+      "enc_ms": 16.1723,
+      "dec_ms": 9.8878,
+      "bytes": 80129
+    }
+  },
+  "github_issues.json": {
+    "json": {
+      "enc_ms": 1.7021,
+      "dec_ms": 1.6101,
+      "bytes": 586232
+    },
+    "yaml": {
+      "enc_ms": 26.3511,
+      "dec_ms": 29.2057,
+      "bytes": 611160
+    },
+    "jaro": {
+      "enc_ms": 15.8619,
+      "dec_ms": 6.1725,
+      "bytes": 489890
+    },
+    "jaro-bin": {
+      "enc_ms": 3.7143,
+      "dec_ms": 3.1443,
+      "bytes": 338660
+    }
+  },
+  "npm_express.json": {
+    "json": {
+      "enc_ms": 2.7538,
+      "dec_ms": 2.9251,
+      "bytes": 823554
+    },
+    "yaml": {
+      "enc_ms": 76.9453,
+      "dec_ms": 90.4213,
+      "bytes": 901268
+    },
+    "jaro": {
+      "enc_ms": 22.2323,
+      "dec_ms": 17.9035,
+      "bytes": 651129
+    },
+    "jaro-bin": {
+      "enc_ms": 13.8868,
+      "dec_ms": 13.8993,
+      "bytes": 288935
+    }
+  },
+  "recipe_book.json": {
+    "json": {
+      "enc_ms": 0.0644,
+      "dec_ms": 0.0606,
+      "bytes": 15705
+    },
+    "yaml": {
+      "enc_ms": 1.4042,
+      "dec_ms": 1.6185,
+      "bytes": 16450
+    },
+    "jaro": {
+      "enc_ms": 0.4675,
+      "dec_ms": 0.3439,
+      "bytes": 10919
+    },
+    "jaro-bin": {
+      "enc_ms": 0.3315,
+      "dec_ms": 0.2507,
+      "bytes": 8045
+    }
+  },
+  "twitter.json": {
+    "json": {
+      "enc_ms": 1.2749,
+      "dec_ms": 2.0924,
+      "bytes": 466906
+    },
+    "yaml": {
+      "enc_ms": 32.5884,
+      "dec_ms": 37.0575,
+      "bytes": 506544
+    },
+    "jaro": {
+      "enc_ms": 9.0975,
+      "dec_ms": 7.5778,
+      "bytes": 330143
+    },
+    "jaro-bin": {
+      "enc_ms": 5.0219,
+      "dec_ms": 5.2839,
+      "bytes": 139016
+    }
+  }
+}