pytest-benchmem 0.4.2__tar.gz → 0.4.3__tar.gz

{pytest_benchmem-0.4.2 → pytest_benchmem-0.4.3}/.github/dependabot.yml

@@ -1,10 +1,10 @@
 version: 2
 
 updates:
-  - package-ecosystem: "pip"
+  - package-ecosystem: "uv"
     directory: "/"
     schedule:
-      interval: "weekly"
+      interval: "monthly"
     labels:
       - "dependencies"
     commit-message:
@@ -27,7 +27,7 @@ updates:
   - package-ecosystem: "github-actions"
     directory: "/"
     schedule:
-      interval: "weekly"
+      interval: "monthly"
     labels:
       - "dependencies"
     commit-message:

{pytest_benchmem-0.4.2 → pytest_benchmem-0.4.3}/.github/workflows/ci.yaml

@@ -16,11 +16,11 @@ jobs:
     runs-on: ubuntu-24.04
     timeout-minutes: 5
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
       - uses: astral-sh/setup-uv@v7
         with:
           enable-cache: true
-      - run: uv sync --group dev
+      - run: uv sync --group dev --frozen
       - run: uv run ruff check --output-format=github
       - run: uv run ruff format --diff
 
@@ -29,11 +29,11 @@ jobs:
     runs-on: ubuntu-24.04
     timeout-minutes: 5
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
       - uses: astral-sh/setup-uv@v7
         with:
           enable-cache: true
-      - run: uv sync --group dev
+      - run: uv sync --group dev --frozen
       - run: uv run mypy src/pytest_benchmem tests
 
   test:
@@ -49,14 +49,14 @@ jobs:
           - os: macos-latest
             python-version: "3.13"
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
       - uses: astral-sh/setup-uv@v7
         with:
           enable-cache: true
       - uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}
-      - run: uv sync --group dev
+      - run: uv sync --group dev --frozen
       - run: uv run pytest -q
 
   smoke-install:
@@ -64,7 +64,7 @@ jobs:
     runs-on: ubuntu-24.04
     timeout-minutes: 10
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
       - uses: astral-sh/setup-uv@v7
         with:
           enable-cache: true

{pytest_benchmem-0.4.2 → pytest_benchmem-0.4.3}/.github/workflows/docs.yaml

@@ -18,11 +18,11 @@ jobs:
     runs-on: ubuntu-24.04
     timeout-minutes: 10
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
       - uses: astral-sh/setup-uv@v7
         with:
           enable-cache: true
       # Build the notebooks from their jupytext sources, then build+execute the site.
-      - run: uv sync --group docs
+      - run: uv sync --group docs --frozen
       - run: uv run jupytext --to ipynb docs/compare-plot.md
       - run: uv run mkdocs gh-deploy --force

{pytest_benchmem-0.4.2 → pytest_benchmem-0.4.3}/.github/workflows/nightly.yaml

@@ -31,7 +31,7 @@ jobs:
             python: "3.13"
             resolution: "--upgrade"
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
       - uses: astral-sh/setup-uv@v7
       - uses: actions/setup-python@v6
         with:

{pytest_benchmem-0.4.2 → pytest_benchmem-0.4.3}/.github/workflows/release.yaml

@@ -49,7 +49,7 @@ jobs:
       name: pypi
       url: https://pypi.org/project/pytest-benchmem
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
         with:
           ref: ${{ github.event_name == 'workflow_dispatch' && inputs.tag || needs.release-please.outputs.tag_name }}
           fetch-depth: 0

{pytest_benchmem-0.4.2 → pytest_benchmem-0.4.3}/.gitignore

@@ -10,9 +10,6 @@ build/
 .pytest_cache/
 *.bin
 
-# lockfile not tracked for a library — resolve fresh against current deps
-uv.lock
-
 # jupytext-built notebooks (source is the .md) + mkdocs build
 docs/*.ipynb
 site/

pytest_benchmem-0.4.3/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.4.3"
+}

{pytest_benchmem-0.4.2 → pytest_benchmem-0.4.3}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.4.3](https://github.com/fluxopt/pytest-benchmem/compare/v0.4.2...v0.4.3) (2026-06-29)
+
+
+### Features
+
+* benchmem compare accepts a single run (plain table) ([#123](https://github.com/fluxopt/pytest-benchmem/issues/123)) ([96275d9](https://github.com/fluxopt/pytest-benchmem/commit/96275d93628323ffd4f3cc74decdebdcb132004e))
+
 ## [0.4.2](https://github.com/fluxopt/pytest-benchmem/compare/v0.4.1...v0.4.2) (2026-06-18)
 
 

{pytest_benchmem-0.4.2 → pytest_benchmem-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-benchmem
-Version: 0.4.2
+Version: 0.4.3
 Summary: The memory companion to pytest-benchmark: a memray peak-memory pass on the same test, plus dims-aware plots and cross-version sweeps.
 Project-URL: Homepage, https://github.com/fluxopt/pytest-benchmem
 Project-URL: Documentation, https://fluxopt.github.io/pytest-benchmem/

pytest_benchmem-0.4.3/docs/changelog.md

@@ -0,0 +1,9 @@
+---
+hide:
+  - navigation
+---
+
+<!-- Rendered from the repo-root CHANGELOG.md (release-please source of truth) so the
+     published release notes can't drift from the tagged releases. -->
+
+--8<-- "CHANGELOG.md"

{pytest_benchmem-0.4.2 → pytest_benchmem-0.4.3}/mkdocs.yml

@@ -39,6 +39,7 @@ nav:
       - Grouping by dims: dims.md
       - Cross-version sweeps: sweeps.md
   - Reference: reference.md
+  - Release notes: changelog.md
 
 plugins:
   - search
@@ -93,6 +94,10 @@ markdown_extensions:
       anchor_linenums: true
       use_pygments: true
   - pymdownx.inlinehilite
+  - pymdownx.snippets:
+      # Pull docs/changelog.md's `--8<-- "CHANGELOG.md"` from the repo root.
+      base_path: ["."]
+      check_paths: true
   - pymdownx.superfences
   - pymdownx.details
   - pymdownx.tabbed:

{pytest_benchmem-0.4.2 → pytest_benchmem-0.4.3}/pyproject.toml

@@ -48,7 +48,8 @@ build-backend = "hatchling.build"
 source = "vcs"
 
 [dependency-groups]
-dev = ["ruff", "mypy", "pre-commit", "pytest-benchmem[plot]", { include-group = "docs" }]
+# mypy <2.1: 2.1.0 errors on numpy's PEP 695 stub under python_version=3.11. Lift once fixed upstream.
+dev = ["ruff", "mypy<2.2", "pre-commit", "pytest-benchmem[plot]", { include-group = "docs" }]
 docs = [
     "jupytext",
     "ipykernel",

{pytest_benchmem-0.4.2 → pytest_benchmem-0.4.3}/src/pytest_benchmem/cli.py

@@ -188,7 +188,10 @@ def plot(
 def compare(
     runs: Annotated[
         list[Path],
-        typer.Argument(help="Two or more pytest-benchmark runs, oldest → newest (a sweep is N)."),
+        typer.Argument(
+            help="One or more pytest-benchmark runs, oldest → newest. One prints a plain "
+            "table; two or more compare (a sweep is N)."
+        ),
     ],
     columns: Annotated[
         str | None,
@@ -233,9 +236,16 @@ def compare(
         ),
     ] = None,
 ) -> None:
-    """Print a per-id comparison table across two or more runs (and optionally gate CI)."""
-    if len(runs) < 2:  # noqa: PLR2004 — a comparison needs two sides
-        raise _fail("compare needs at least two runs", 2)
+    """Print a per-id table for one run, or compare two or more (and optionally gate CI)."""
+    if not runs:
+        raise _fail("compare needs at least one run", 2)
+    if fail_on and len(runs) < 2:  # noqa: PLR2004 — a growth gate needs a before and an after
+        raise _fail(
+            "compare --fail-on needs at least two runs — it gates growth of the first run vs "
+            "the last. For an absolute ceiling on a single run, use the "
+            "@pytest.mark.benchmem(max_peak=...) marker instead.",
+            2,
+        )
     _require_runs_exist(runs, suggest=False)
     from pytest_benchmem.compare import compare_runs, find_regressions, parse_threshold
 

{pytest_benchmem-0.4.2 → pytest_benchmem-0.4.3}/src/pytest_benchmem/compare.py

@@ -1,11 +1,12 @@
-"""Text comparison of two or more pytest-benchmark runs — keyed on the benchmark id.
+"""Text table for one or more pytest-benchmark runs — keyed on the benchmark id.
 
-:func:`compare_runs` prints the comparison table, modelled on pytest-benchmark's own:
+:func:`compare_runs` prints the table, modelled on pytest-benchmark's own:
 rows are one per ``(benchmark × run)``, columns are ``metric × stat`` (``--columns``
 picks the metrics, default ``time,peak``; ``--stat`` picks the stat, default ``all`` for
-the full min/max/mean/median/stddev spread), every cell carries a relative ``(N.NN)``
-multiplier vs its column's best (best green, worst red), and ``group_by`` splits the rows
-into sub-tables.
+the full min/max/mean/median/stddev spread), and ``group_by`` splits the rows into
+sub-tables. With **two or more** runs every cell carries a relative ``(N.NN)`` multiplier
+vs its column's best (best green, worst red); a **single** run is a plain readout — there's
+no other run to rank against, so the multiplier and colour are dropped.
 
 The rest is the regression gate behind ``benchmem compare --fail-on``: parse a threshold
 like ``peak:10%`` / ``peak:5MiB`` / ``allocations:5%`` / ``time:5%``, find the ids whose
@@ -227,15 +228,15 @@ def compare_runs(
     csv: Path | None = None,
     out: TextIO | None = None,
 ) -> None:
-    """Print a per-(benchmark, run) comparison table across two or more runs.
+    """Print a per-(benchmark, run) table for one or more runs.
 
     Mirrors pytest-benchmark's table model: rows are one per ``(benchmark × run)``,
     ``columns`` selects which metric columns appear (``time`` / ``peak`` / ``allocated``
-    / ``allocations``), each cell carries the value plus a relative ``(N.NN)`` multiplier
-    vs the group's best (best green, worst red), and ``group_by`` splits the rows into
-    sub-tables (``fullname`` / ``name`` / ``func`` / ``group`` / ``module`` / ``class`` /
-    ``param:NAME``, comma-composable). With no ``group_by`` the whole comparison is one
-    table.
+    / ``allocations``). With two or more runs each cell also carries a relative ``(N.NN)``
+    multiplier vs the group's best (best green, worst red); a single run is a plain readout
+    with neither. ``group_by`` splits the rows into sub-tables (``fullname`` / ``name`` /
+    ``func`` / ``group`` / ``module`` / ``class`` / ``param:NAME``, comma-composable). With
+    no ``group_by`` the whole comparison is one table.
 
     Every column is a ``metric × stat`` pair. ``columns`` is a comma list of metric names
     (default ``time,peak``); ``stat`` is one of ``min`` / ``max`` / ``mean`` / ``median`` /
@@ -254,11 +255,16 @@ def compare_runs(
         raise ValueError(f"unknown --sort {sort!r}; use one of {', '.join(_SORTS)}")
     metrics, stats = _resolve_columns(columns), _resolve_stats(stat)
     labels, values, units, dims = _load_columns(runs, metrics, stats)
-    if len(labels) < 2:  # noqa: PLR2004 — a comparison needs two sides
+    if not labels:
+        raise ValueError("no benchmarks found in the given run(s)")
+    if len(labels) < 2 and len(runs) > 1:  # noqa: PLR2004 — distinct paths collapsed to one series
         raise ValueError(
             f"compare needs at least two distinct runs; got {labels!r} "
             f"(the same file more than once?). Pass distinct files."
         )
+    # One run is a plain readout: with no other run to rank against, the (N.NN) multiplier and
+    # the best/worst colour are meaningless (best == worst == the value), so they're dropped.
+    single = len(labels) == 1
     with_data = {col_id for col_id, _i, _lab in values}
     all_cols = [(m, s) for m in metrics for s in stats]
     cols = [(m, s) for m, s in all_cols if f"{m}:{s}" in with_data] or all_cols  # drop empties
@@ -338,7 +344,9 @@ def compare_runs(
                     if unit == ""
                     else f"{v:.4g}"
                 )
-                cells.append(Text(body + _mult(v, best), style=rank_style(v, best, worst) or ""))
+                mult = "" if single else _mult(v, best)
+                style = "" if single else (rank_style(v, best, worst) or "")
+                cells.append(Text(body + mult, style=style))
             table.add_row(*cells)
         console.print(table)
         console.print()  # one blank line between sub-tables

{pytest_benchmem-0.4.2 → pytest_benchmem-0.4.3}/tests/test_cli.py

@@ -60,6 +60,23 @@ def test_compare_prints_table(tmp_path):
     assert "(2.00)" in result.output and "time (s)" in result.output
 
 
+def test_compare_single_run_prints_table(tmp_path):
+    # one run is allowed now: a plain table, no comparison multiplier
+    a = _run(tmp_path, "run.json", [_bm("test_x", t=1.0, peak=10 * 1024**2)])
+    result = runner.invoke(app, ["compare", str(a), "--columns", "time,peak"])
+    assert result.exit_code == 0, _text(result)
+    assert "time (s)" in result.output and "peak (MiB)" in result.output
+    assert "(1.0)" not in result.output  # nothing to rank against
+
+
+def test_compare_single_run_with_fail_on_exits_2(tmp_path):
+    # --fail-on gates growth of one run vs another, so it needs two; refuse, don't silently pass
+    a = _run(tmp_path, "run.json", [_bm("test_x", peak=100)])
+    result = runner.invoke(app, ["compare", str(a), "--fail-on", "peak:10%"])
+    assert result.exit_code == 2
+    assert "at least two runs" in _text(result)
+
+
 def test_compare_columns_selects_time_and_peak(tmp_path):
     a = _run(tmp_path, "base.json", [_bm("test_x", t=1.0, peak=10 * 1024**2)])
     b = _run(tmp_path, "head.json", [_bm("test_x", t=1.0, peak=20 * 1024**2)])

{pytest_benchmem-0.4.2 → pytest_benchmem-0.4.3}/tests/test_compare.py

@@ -57,6 +57,38 @@ def test_same_file_twice_errors_cleanly(tmp_path):
         compare_runs([a, a], out=StringIO())
 
 
+def test_single_run_prints_plain_table(tmp_path):
+    # one run is a valid input: a plain readout, no cross-run multiplier or ranking colour
+    a = _write(tmp_path / "run.json", [_bm("test_x", t=1.0, peak=10 * 1024**2)])
+    out = StringIO()
+    compare_runs([a], columns="time,peak", out=out)
+    text = out.getvalue()
+    assert "time (s)" in text and "peak (MiB)" in text  # the columns still render
+    rows = _lines(text, "test_x")
+    assert "(run)" in rows  # the single run's label still names the row
+    assert "(1.0)" not in rows  # nothing to compare against → no relative multiplier
+
+
+def test_single_run_multi_id_has_no_within_run_ranking(tmp_path):
+    # a single run with several ids in one group is still plain — no (N.NN) ranking the
+    # ids against each other (that's reserved for the cross-run comparison).
+    a = _write(
+        tmp_path / "run.json",
+        [_bm("pkg::test_op[n=1]", peak=1024), _bm("pkg::test_op[n=2]", peak=10 * 1024**2)],
+    )
+    out = StringIO()
+    compare_runs([a], columns="peak", group_by="func", out=out)
+    text = out.getvalue()
+    assert "test_op[n=1]" in text and "test_op[n=2]" in text
+    assert "(1.0)" not in text and "(10240.00)" not in text  # no within-run multiplier
+
+
+def test_single_run_empty_file_errors(tmp_path):
+    a = _write(tmp_path / "run.json", [])
+    with pytest.raises(ValueError, match="no benchmarks"):
+        compare_runs([a], out=StringIO())
+
+
 def test_distinct_files_same_stem_disambiguate(tmp_path):
     # two real runs that happen to share a stem (v1/bench.json vs v2/bench.json)
     # is a legit comparison and must not collapse to one series.