python-json-logger 4.1.0__tar.gz → 4.3.0.dev2__tar.gz

python_json_logger-4.3.0.dev2/MANIFEST.in

@@ -0,0 +1,5 @@
+include LICENSE
+include README.md
+recursive-include tests *.py
+include scripts/benchmark_report.py
+include scripts/benchmark_plots.py

{python_json_logger-4.1.0/src/python_json_logger.egg-info → python_json_logger-4.3.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-json-logger
-Version: 4.1.0
+Version: 4.3.0.dev2
 Summary: JSON Log Formatter for the Python Logging Package
 Author-email: Zakaria Zajac <zak@madzak.com>, Nicholas Hairs <info+python-json-logger@nicholashairs.com>
 Maintainer-email: Nicholas Hairs <info+python-json-logger@nicholashairs.com>
@@ -16,30 +16,12 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: System :: Logging
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Provides-Extra: dev
-Requires-Dist: orjson; implementation_name != "pypy" and extra == "dev"
-Requires-Dist: msgspec; implementation_name != "pypy" and extra == "dev"
-Requires-Dist: validate-pyproject[all]; extra == "dev"
-Requires-Dist: black; extra == "dev"
-Requires-Dist: pylint; extra == "dev"
-Requires-Dist: mypy; extra == "dev"
-Requires-Dist: pytest; extra == "dev"
-Requires-Dist: freezegun; extra == "dev"
-Requires-Dist: tzdata; extra == "dev"
-Requires-Dist: build; extra == "dev"
-Requires-Dist: mkdocs; extra == "dev"
-Requires-Dist: mkdocs-material>=8.5; extra == "dev"
-Requires-Dist: mkdocs-awesome-pages-plugin; extra == "dev"
-Requires-Dist: mdx_truly_sane_lists; extra == "dev"
-Requires-Dist: mkdocstrings[python]; extra == "dev"
-Requires-Dist: mkdocs-gen-files; extra == "dev"
-Requires-Dist: mkdocs-literate-nav; extra == "dev"
-Requires-Dist: mike; extra == "dev"
 Dynamic: license-file
 
 [![PyPi](https://img.shields.io/pypi/v/python-json-logger.svg)](https://pypi.python.org/pypi/python-json-logger/)

{python_json_logger-4.1.0 → python_json_logger-4.3.0.dev2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-json-logger"
-version = "4.1.0"
+version = "4.3.0.dev2"
 description = "JSON Log Formatter for the Python Logging Package"
 authors = [
     {name = "Zakaria Zajac", email = "zak@madzak.com"},
@@ -31,6 +31,7 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
     "Topic :: System :: Logging",
     "Typing :: Typed",
 ]
@@ -39,7 +40,15 @@ classifiers = [
 Homepage = "https://nhairs.github.io/python-json-logger"
 GitHub = "https://github.com/nhairs/python-json-logger"
 
-[project.optional-dependencies]
+[dependency-groups]
+benchmark-report = ["matplotlib>=3.8,<4"]
+benchmark = [
+    # pytest-benchmark 5.x uses Node._nodeid, removed in pytest 9.2.
+    "pytest<9.2",
+    "pytest-benchmark>=5.1,<6",
+    "orjson;implementation_name!='pypy'",
+    "msgspec;implementation_name!='pypy'",
+]
 dev = [
     ## Optional but required for dev
     "orjson;implementation_name!='pypy'",
@@ -48,7 +57,7 @@ dev = [
     "validate-pyproject[all]",
     "black",
     "pylint",
-    "mypy",
+    "pyrefly",
     ## Test
     "pytest",
     "freezegun",
@@ -56,7 +65,7 @@ dev = [
     ## Build
     "build",
     ## Docs
-    "mkdocs",
+    "mkdocs<2",
     "mkdocs-material>=8.5",
     "mkdocs-awesome-pages-plugin",
     "mdx_truly_sane_lists",
@@ -64,6 +73,7 @@ dev = [
     "mkdocs-gen-files",
     "mkdocs-literate-nav",
     "mike",
+    "packaging",
 ]
 
 [tool.setuptools.packages.find]
@@ -75,3 +85,6 @@ pythonjsonlogger = ["py.typed"]
 
 [tool.black]
 line-length = 100
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

python_json_logger-4.3.0.dev2/scripts/benchmark_plots.py

@@ -0,0 +1,234 @@
+"""Export timing and speedup plots from the committed benchmark summaries."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+from matplotlib.figure import Figure
+
+from benchmark_report import (
+    LAYERS,
+    WORKLOADS,
+    comparison_groups,
+    formatting_summary,
+    load_results,
+    render,
+)
+
+COLORS = {
+    "json (CPython)": "#0072B2",
+    "orjson (CPython)": "#D55E00",
+    "msgspec (CPython)": "#009E73",
+    "json (PyPy)": "#CC79A7",
+}
+STYLE = {
+    "font.family": "DejaVu Sans",
+    "svg.fonttype": "none",
+    "svg.hashsalt": "python-json-logger-benchmark",
+}
+
+
+def make_speedup_plot(result: dict) -> Figure:
+    """Compare grouped speedup bars in two panels with workload boundaries."""
+    backends = result["backends"]
+    cases = result["cases"]
+    reference = "json (CPython)" if "json (CPython)" in backends else "json (PyPy)"
+    figure, axes = plt.subplots(1, 2, figsize=(13, 8))
+    height = 0.8 / len(backends)
+    for axis, layer in zip(axes, LAYERS):
+        upper = 1.0
+        for index, backend in enumerate(backends):
+            positions = [row - 0.4 + height * (index + 0.5) for row in range(len(WORKLOADS))]
+            values = [
+                cases[layer, workload, reference]["median"]
+                / cases[layer, workload, backend]["median"]
+                for workload in WORKLOADS
+            ]
+            upper = max(upper, max(values))
+            axis.barh(
+                positions,
+                values,
+                height=height * 0.85,
+                color=COLORS[backend],
+                label=backend,
+                zorder=2,
+            )
+            for position, value in zip(positions, values):
+                axis.annotate(
+                    f"{value:.2g}×",
+                    (value, position),
+                    xytext=(4, 0),
+                    textcoords="offset points",
+                    va="center",
+                    fontsize=8,
+                )
+        axis.set_yticks(range(len(WORKLOADS)), WORKLOADS)
+        axis.set_ylim(len(WORKLOADS) - 0.5, -0.5)
+        axis.set_xlim(0, upper * 1.2)
+        for row in range(len(WORKLOADS)):
+            if row % 2 == 0:
+                axis.axhspan(row - 0.5, row + 0.5, color="#000000", alpha=0.045, zorder=0)
+            axis.axhline(row + 0.5, color="#888888", alpha=0.3, linewidth=0.7)
+        axis.set_title("Serialization" if layer == "serialization" else "Complete formatting")
+        axis.set_xlabel("Speedup (×) — higher is faster")
+        axis.grid(axis="x", alpha=0.25)
+        axis.set_axisbelow(True)
+    figure.suptitle(f"Python {result['python']}: Ratios of median times", fontsize=15)
+    handles, labels = axes[0].get_legend_handles_labels()
+    figure.legend(
+        handles, labels, loc="lower center", bbox_to_anchor=(0.5, 0.065), ncol=len(backends)
+    )
+    figure.text(
+        0.5,
+        0.025,
+        f"Speedup relative to {reference} (1×). Descriptive ratios have no confidence intervals.",
+        ha="center",
+        fontsize=9,
+    )
+    figure.tight_layout(rect=(0, 0.14, 1, 0.94))
+    return figure
+
+
+def make_plot(result: dict, kind: str) -> Figure:
+    """Compare labeled horizontal bars in separate linear-scale workload panels."""
+    if kind == "speedup":
+        return make_speedup_plot(result)
+    backends = result["backends"]
+    cases = result["cases"]
+    figure, axes = plt.subplots(len(WORKLOADS), len(LAYERS), figsize=(13, 16))
+    for row, workload in enumerate(WORKLOADS):
+        for col, layer in enumerate(LAYERS):
+            axis = axes[row, col]
+            stats = [cases[layer, workload, backend] for backend in backends]
+            values = [item["median"] * 1e6 for item in stats]
+            labels = [f"{value:.3g}" for value in values]
+            axis.barh(
+                range(len(backends)),
+                values,
+                height=0.65,
+                color=[COLORS[backend] for backend in backends],
+                alpha=0.85,
+                zorder=2,
+            )
+            upper = max(values)
+            for index, label in enumerate(labels):
+                axis.text(values[index] + upper * 0.025, index, label, va="center", fontsize=9)
+            axis.set_yticks(range(len(backends)), backends, fontsize=9)
+            axis.invert_yaxis()
+            axis.set_xlim(0, upper * 1.23)
+            layer_title = "Serialization" if layer == "serialization" else "Complete formatting"
+            axis.set_title(f"{workload} · {layer_title}", fontsize=11)
+            axis.set_xlabel("Median time (µs)", fontsize=9)
+            axis.grid(axis="x", alpha=0.25, zorder=0)
+            axis.set_axisbelow(True)
+            axis.spines[["top", "right"]].set_visible(False)
+    figure.suptitle(f"Python {result['python']}: Median operation times", fontsize=15)
+    caption = (
+        "Every panel starts at zero; axis ranges differ by panel. Lower is faster.\n"
+        "Labels show median µs. Variation statistics are available in the tables."
+    )
+    figure.text(0.5, 0.012, caption, ha="center", fontsize=10)
+    figure.tight_layout(rect=(0, 0.045, 1, 0.97), h_pad=1.5, w_pad=2)
+    return figure
+
+
+def make_summary_plot(summary: dict) -> Figure:
+    """Combine workload timing and speedup panels into one shareable figure."""
+    figure, axes = plt.subplots(len(WORKLOADS), 2, figsize=(13, 16))
+    for row, workload in enumerate(WORKLOADS):
+        for col, kind in enumerate(("times", "speedup")):
+            axis = axes[row, col]
+            backends = [
+                backend for backend, metrics in summary[workload].items() if kind in metrics
+            ]
+            stats = [summary[workload][backend][kind] for backend in backends]
+            values = [item["mean"] for item in stats]
+            errors = [
+                [item["mean"] - item["min"] for item in stats],
+                [item["max"] - item["mean"] for item in stats],
+            ]
+            axis.barh(
+                range(len(backends)),
+                values,
+                xerr=errors,
+                capsize=4,
+                color=[COLORS[backend] for backend in backends],
+                alpha=0.85,
+                error_kw={"elinewidth": 1.2},
+                zorder=2,
+            )
+            upper = max((item["max"] for item in stats), default=1)
+            for index, item in enumerate(stats):
+                precision = 3 if kind == "times" else 2
+                suffix = "" if kind == "times" else "×"
+                axis.text(
+                    item["max"] + upper * 0.025,
+                    index,
+                    f"{item['mean']:.{precision}g}{suffix}",
+                    va="center",
+                    fontsize=9,
+                )
+            axis.set_yticks(range(len(backends)), backends, fontsize=9)
+            axis.invert_yaxis()
+            axis.set_xlim(0, upper * 1.25)
+            axis.set_title(f"{workload} · {'Timing' if kind == 'times' else 'Speedup'}")
+            axis.set_xlabel(
+                "Time (µs) — lower is faster"
+                if kind == "times"
+                else "Speedup (×) — higher is faster"
+            )
+            if kind == "speedup":
+                axis.axvline(1, color="#555555", linestyle="--", linewidth=1)
+            axis.grid(axis="x", alpha=0.25)
+            axis.set_axisbelow(True)
+            axis.spines[["top", "right"]].set_visible(False)
+    figure.suptitle("Complete formatting across Python versions", fontsize=15)
+    figure.text(
+        0.5,
+        0.012,
+        "Bars: arithmetic mean across versions. Whiskers: version minimum–maximum, not sample variation.\n"
+        "Speedups use version-matched CPython stdlib JSON. Scales and version coverage differ; see the documentation.",
+        ha="center",
+        fontsize=10,
+    )
+    figure.tight_layout(rect=(0, 0.045, 1, 0.97), h_pad=1.5, w_pad=2)
+    return figure
+
+
+def save_plot(figure: Figure, target: Path) -> None:
+    """Save SVG without timestamps or trailing whitespace."""
+    figure.savefig(target, metadata={"Date": None})
+    target.write_text(
+        "\n".join(line.rstrip() for line in target.read_text(encoding="utf-8").splitlines()) + "\n",
+        encoding="utf-8",
+    )
+    plt.close(figure)
+    return
+
+
+def main() -> None:
+    """Write deterministic SVG files; install the benchmark-report dependency group."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("results", type=Path, nargs="+")
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args()
+    render(args.results)  # Validate matrices and statistics before producing any plots.
+    args.output.mkdir(parents=True, exist_ok=True)
+    with matplotlib.rc_context(STYLE):
+        for result in comparison_groups(load_results(args.results)):
+            for kind in ("times", "speedup"):
+                figure = make_plot(result, kind)
+                target = args.output / f"python-{result['python']}-{kind}.svg"
+                save_plot(figure, target)
+        summary = formatting_summary(comparison_groups(load_results(args.results)))
+        save_plot(make_summary_plot(summary), args.output / "summary.svg")
+    return
+
+
+if __name__ == "__main__":
+    main()

python_json_logger-4.3.0.dev2/scripts/benchmark_report.py

@@ -0,0 +1,301 @@
+"""Generate benchmark tables from pytest-benchmark JSON without extra dependencies."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+from pathlib import Path
+from statistics import fmean
+from textwrap import indent
+
+START = "<!-- benchmark-results:start -->"
+END = "<!-- benchmark-results:end -->"
+SUMMARY_START = "<!-- benchmark-summary:start -->"
+SUMMARY_END = "<!-- benchmark-summary:end -->"
+SERIES = ("json (CPython)", "orjson (CPython)", "msgspec (CPython)", "json (PyPy)")
+BACKENDS = ("json", "orjson", "msgspec")
+LAYERS = ("serialization", "formatting")
+WORKLOADS = ("simple", "structured", "nested", "unicode", "rich", "exception")
+
+
+def load_results(paths: list[Path]) -> list[dict]:
+    """Load summary statistics in deterministic runtime order."""
+    results = []
+    for path in paths:
+        result = json.loads(path.read_text(encoding="utf-8"))
+        # Raw exports can contain millions of samples; retain only table inputs.
+        for benchmark in result["benchmarks"]:
+            benchmark["stats"].pop("data", None)
+        results.append(result)
+    results.sort(
+        key=lambda result: (
+            tuple(map(int, result["environment"]["python"].split(".")[:2])),
+            result["environment"].get("implementation", "CPython"),
+        )
+    )
+    return results
+
+
+def comparison_groups(results: list[dict]) -> list[dict]:
+    """Validate exports and group implementations by Python major/minor version."""
+    groups: dict[str, dict] = {}
+    runtimes = set()
+    for result in results:
+        environment = result["environment"]
+        python = environment["python"]
+        implementation = environment.get("implementation", "CPython")
+        minor = ".".join(python.split(".")[:2])
+        runtime = (implementation, minor)
+        if implementation not in ("CPython", "PyPy"):
+            raise ValueError(f"Unsupported implementation: {implementation}")
+        if runtime in runtimes:
+            raise ValueError(f"Duplicate runtime: {runtime}")
+        runtimes.add(runtime)
+        backends = tuple(environment.get("backends", BACKENDS))
+        if "json" not in backends or not set(backends).issubset(BACKENDS):
+            raise ValueError(f"Invalid backend list for Python {python}")
+        cases = {}
+        for benchmark in result["benchmarks"]:
+            info = benchmark["extra_info"]
+            key = (info["layer"], info["workload"], info["backend"])
+            if key in cases:
+                raise ValueError(f"Duplicate case: {key}")
+            median = benchmark["stats"]["median"]
+            if not math.isfinite(median) or median <= 0:
+                raise ValueError(f"Invalid median: {key}")
+            stats = benchmark["stats"]
+            for name in ("mean", "stddev", "iqr", "q1", "q3"):
+                if not math.isfinite(stats[name]) or stats[name] < 0:
+                    raise ValueError(f"Invalid {name}: {key}")
+            if stats["mean"] <= 0:
+                raise ValueError(f"Invalid mean: {key}")
+            if not 0 < stats["q1"] <= median <= stats["q3"]:
+                raise ValueError(f"Invalid quartiles: {key}")
+            if stats["rounds"] < 1 or stats["iterations"] < 1:
+                raise ValueError(f"Invalid repetition counts: {key}")
+            cases[key] = stats
+        required = {
+            (layer, workload, backend)
+            for layer in LAYERS
+            for workload in WORKLOADS
+            for backend in backends
+        }
+        if set(cases) != required:
+            raise ValueError(f"Incomplete or unexpected matrix for Python {python}")
+        group = groups.setdefault(
+            minor, {"python": minor, "sources": [], "cases": {}, "backends": []}
+        )
+        group["sources"].append(result)
+        for backend in backends:
+            label = f"{backend} ({implementation})"
+            group["backends"].append(label)
+            for layer in LAYERS:
+                for workload in WORKLOADS:
+                    group["cases"][layer, workload, label] = cases[layer, workload, backend]
+    return list(groups.values())
+
+
+def formatting_summary(groups: list[dict]) -> dict:
+    """Aggregate per-version medians and matched CPython-relative ratios.
+
+    Missing CPython references contribute timings but no speedup ratios.
+    Each metric retains its own version coverage.
+    """
+    summary = {}
+    for workload in WORKLOADS:
+        summary[workload] = {}
+        for backend in SERIES:
+            metrics = {}
+            for kind in ("times", "speedup"):
+                values = []
+                versions = []
+                for group in groups:
+                    cases = group["cases"]
+                    key = ("formatting", workload, backend)
+                    reference = ("formatting", workload, "json (CPython)")
+                    if key not in cases or (kind == "speedup" and reference not in cases):
+                        continue
+                    timing = cases[key]["median"]
+                    values.append(
+                        timing * 1e6 if kind == "times" else cases[reference]["median"] / timing
+                    )
+                    versions.append(group["python"])
+                if values:
+                    metrics[kind] = {
+                        "mean": fmean(values),
+                        "min": min(values),
+                        "max": max(values),
+                        "versions": versions,
+                    }
+            if metrics:
+                summary[workload][backend] = metrics
+    return summary
+
+
+def render(paths: list[Path], plots: str | None = None) -> str:
+    """Render version sections comparing encoders and Python implementations."""
+    results = load_results(paths)
+    sections = []
+    for group in comparison_groups(results):
+        python = group["python"]
+        backends = group["backends"]
+        cases = group["cases"]
+        sections.extend([f"### Python {python}", ""])
+        for result in group["sources"]:
+            environment = result["environment"]
+            implementation = environment.get("implementation", "CPython")
+            machine = result["machine_info"]
+            cpu = machine.get("cpu", {}).get("brand_raw", machine.get("processor", "unknown"))
+            sections.extend(
+                [
+                    f"**{implementation} {environment['python']}**. Measured: {result['datetime']}. "
+                    f"Revision: `{environment['revision']}`"
+                    + (" (working tree modified)." if environment["dirty"] else "."),
+                    "",
+                    f"Environment: {machine['system']} {machine['release']}, {machine['machine']}; {cpu}."
+                    + (
+                        f" PyPy release: {machine['python_implementation_version']}."
+                        if implementation == "PyPy" and "python_implementation_version" in machine
+                        else ""
+                    ),
+                    "",
+                    "Dependencies: "
+                    + ", ".join(
+                        f"`{key}=={value}`"
+                        for key, value in sorted(environment["dependencies"].items())
+                    )
+                    + ".",
+                    "",
+                ]
+            )
+        sections.extend(["#### Times and variation", ""])
+        slug = f"python-{python}"
+        if plots:
+            sections.extend(
+                [
+                    f"![Median operation times for Python {python}]({plots}/{slug}-times.svg)",
+                    "",
+                ]
+            )
+        sections.extend(
+            [
+                "| Layer | Workload | Encoder | Median (µs) | IQR (µs) | Mean ± SD (µs) | Rounds × iterations |",
+                "| --- | --- | --- | ---: | ---: | ---: | ---: |",
+            ]
+        )
+        for layer in LAYERS:
+            for workload in WORKLOADS:
+                for backend in backends:
+                    stats = cases[layer, workload, backend]
+                    sections.append(
+                        f"| {layer} | {workload} | {backend} | "
+                        f"{stats['median'] * 1e6:.3g} | {stats['iqr'] * 1e6:.2g} | "
+                        f"{stats['mean'] * 1e6:.3g} ± {stats['stddev'] * 1e6:.2g} | "
+                        f"{stats['rounds']:,} × {stats['iterations']:,} |"
+                    )
+        sections.extend(["", "#### Speedup", ""])
+        if plots:
+            sections.extend(
+                [
+                    f"![Median speedups relative to stdlib JSON for Python {python}]({plots}/{slug}-speedup.svg)",
+                    "",
+                ]
+            )
+        reference = "json (CPython)" if "json (CPython)" in backends else "json (PyPy)"
+        sections.extend([f"Reference: {reference} (1×).", ""])
+        sections.extend(
+            [
+                "| Layer | Workload | " + " | ".join(backends) + " |",
+                "| --- | --- | " + " | ".join("---:" for _ in backends) + " |",
+            ]
+        )
+        for layer in LAYERS:
+            for workload in WORKLOADS:
+                baseline = cases[layer, workload, reference]["median"]
+                cells = []
+                for backend in backends:
+                    timing = cases[layer, workload, backend]["median"]
+                    cells.append(f"{baseline / timing:.2g}×")
+                sections.append(f"| {layer} | {workload} | " + " | ".join(cells) + " |")
+        sections.append("")
+    statistics = [benchmark["stats"] for result in results for benchmark in result["benchmarks"]]
+    rounds = [stats["rounds"] for stats in statistics]
+    iterations = [stats["iterations"] for stats in statistics]
+    variation = [stats["stddev"] / stats["mean"] * 100 for stats in statistics]
+    summary = [
+        f"Observed repetitions: {min(rounds):,}–{max(rounds):,} rounds per case, "
+        f"with {min(iterations):,}–{max(iterations):,} iterations per round. "
+        "Warmup and calibration calls are additional.",
+        "",
+        f"Within-run SD/mean: {min(variation):.2g}%–{max(variation):.2g}% across cases, "
+        "including outliers. This does not measure between-run variation.",
+        "",
+    ]
+    lines = summary + sections
+    collapsed = []
+    in_table = False
+    for line in lines:
+        if line.startswith("|"):
+            if not in_table:
+                title = "Timing statistics" if "Median (µs)" in line else "Speedup values"
+                collapsed.extend([f'??? note "{title}"', ""])
+            collapsed.append(indent(line, "    "))
+            in_table = True
+        else:
+            collapsed.append(line)
+            in_table = False
+    return "\n".join(collapsed)
+
+
+def main() -> None:
+    """Print a summary or replace the generated section of a documentation page."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("results", nargs="+", type=Path)
+    output = parser.add_mutually_exclusive_group()
+    output.add_argument("--update", type=Path, help="Replace the generated section in this page")
+    output.add_argument("--curate", type=Path, help="Save JSON without individual timing samples")
+    parser.add_argument("--plots", help="Relative URL prefix for generated SVG plots")
+    args = parser.parse_args()
+    report = render(args.results, plots=args.plots)
+    if args.curate:
+        names = [path.name for path in args.results]
+        if len(set(names)) != len(names):
+            raise ValueError("Curated result filenames must be unique")
+        args.curate.mkdir(parents=True, exist_ok=True)
+        for path in args.results:
+            raw = path.read_bytes()
+            result = json.loads(raw)
+            for benchmark in result["benchmarks"]:
+                benchmark["stats"].pop("data", None)
+            result["curation"] = {
+                "source_sha256": hashlib.sha256(raw).hexdigest(),
+                "omitted": ["benchmarks[].stats.data"],
+            }
+            (args.curate / path.name).write_text(
+                json.dumps(result, indent=2) + "\n", encoding="utf-8"
+            )
+    elif args.update:
+        text = args.update.read_text(encoding="utf-8")
+        before, rest = text.split(START, 1)
+        _, after = rest.split(END, 1)
+        text = before + START + "\n\n" + report + "\n" + END + after
+        if SUMMARY_START in text:
+            before, rest = text.split(SUMMARY_START, 1)
+            _, after = rest.split(SUMMARY_END, 1)
+            summary = (
+                f"![Complete-formatting times and speedups by workload, with mean and version ranges]"
+                f"({args.plots}/summary.svg)\n"
+                if args.plots
+                else ""
+            )
+            text = before + SUMMARY_START + "\n\n" + summary + "\n" + SUMMARY_END + after
+        args.update.write_text(text, encoding="utf-8")
+    else:
+        print(report)
+    return
+
+
+if __name__ == "__main__":
+    main()