evutils 0.3.10__tar.gz → 0.3.11__tar.gz

{evutils-0.3.10 → evutils-0.3.11}/.github/workflows/release.yaml

@@ -51,7 +51,7 @@ jobs:
           CIBW_ARCHS_MACOS: "x86_64 arm64"
 
       - name: Upload wheels
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
           name: dist-${{ matrix.os }}
           path: wheelhouse/*.whl
@@ -75,7 +75,7 @@ jobs:
         run: pipx run build --sdist
 
       - name: Upload sdist
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
           name: dist-sdist
           path: dist/*.tar.gz
@@ -140,4 +140,4 @@ jobs:
 
       - name: Deploy to GitHub Pages
         id: deployment
-        uses: actions/deploy-pages@v4
+        uses: actions/deploy-pages@v5

{evutils-0.3.10 → evutils-0.3.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: evutils
-Version: 0.3.10
+Version: 0.3.11
 Summary: Utilities for event-based vision
 Keywords: events,dvs,neuromorphic,vision,event-based
 Author-Email: Jakub Mandula <jakub.mandula@pbl.ee.ethz.ch>
@@ -30,17 +30,17 @@ Project-URL: Homepage, https://mandulaj.github.io/evutils/
 Requires-Python: >=3.10
 Requires-Dist: numpy>=2.0.0
 Requires-Dist: opencv-python>=4.2
+Requires-Dist: numba>=0.57
 Provides-Extra: pandas
 Requires-Dist: pandas>=2.3.3; extra == "pandas"
-Provides-Extra: numba
-Requires-Dist: numba>=0.57; extra == "numba"
 Provides-Extra: torch
 Requires-Dist: torch>=2.0; extra == "torch"
 Provides-Extra: hdf5
 Requires-Dist: hdf5plugin==6.0.0; extra == "hdf5"
-Requires-Dist: h5py==3.16.0; extra == "hdf5"
+Requires-Dist: h5py>=3.16.0; extra == "hdf5"
 Provides-Extra: vis
 Requires-Dist: matplotlib>=3.1; extra == "vis"
+Requires-Dist: open3d>=0.19.0; python_version < "3.13" and extra == "vis"
 Requires-Dist: scipy>=1.15.3; extra == "vis"
 Requires-Dist: tqdm>=4.41; extra == "vis"
 Provides-Extra: test
@@ -48,7 +48,8 @@ Requires-Dist: pytest>=9.0.2; extra == "test"
 Requires-Dist: pytest-benchmark>=5.2.3; extra == "test"
 Provides-Extra: compare
 Requires-Dist: expelliarmus>=1.1.0; extra == "compare"
-Requires-Dist: evlib; extra == "compare"
+Requires-Dist: evlib>=0.12.0; python_version >= "3.11" and extra == "compare"
+Requires-Dist: evlib>=0.8.0; python_version < "3.11" and extra == "compare"
 Provides-Extra: docs
 Requires-Dist: sphinx>=8.0.0; extra == "docs"
 Requires-Dist: sphinx-autoapi>=3.6.1; extra == "docs"
@@ -58,7 +59,7 @@ Requires-Dist: sphinx_book_theme>=1.0.0; extra == "docs"
 Requires-Dist: pydata_sphinx_theme>=0.19.0; extra == "docs"
 Requires-Dist: myst-parser>=4.0.0; extra == "docs"
 Provides-Extra: all
-Requires-Dist: evutils[hdf5,numba,pandas,torch,vis]; extra == "all"
+Requires-Dist: evutils[hdf5,pandas,torch,vis]; extra == "all"
 Provides-Extra: dev
 Requires-Dist: evutils[all,docs,test]; extra == "dev"
 Description-Content-Type: text/markdown
@@ -83,10 +84,12 @@ This project draws inspiration from several excellent libraries in the event-bas
 
 
 ## Installation
-We recommend installing `evutils` using `uv`.
+We recommend installing `evutils` using `uv`. 
 ### From PyPi
 ```bash
-uv add evutils[all]
+uv add evutils # Basic library
+uv add evutils[all] # All groups (pandas, numba, torch, hdf5, etc..)
+uv add evutils[dev] # Dev group
 ```
 
 ### From Git
@@ -187,26 +190,6 @@ uv run pytest benchmarks/ --benchmark-group-by=param:fmt    # compare libraries
 
 The benchmarks download a real Prophesee recording on first use. Optional cross-library comparisons run automatically once the libraries are installed (`uv pip install -e ".[compare]"`); OpenEB/Metavision is compared via the Docker image in `benchmarks/docker/`. See [`benchmarks/README.md`](benchmarks/README.md) for details.
 
-Decode/encode throughput on a 12th Gen Intel Core i7-1280P (millions of events per second, higher is better):
-
-**Read** (full-file decode)
-
-| Format | evutils | expelliarmus | evlib |
-| ------ | ------: | -----------: | ----: |
-| EVT2   |      91 |          105 |     5 |
-| EVT2.1 |      72 |            – |     – |
-| EVT3   |      53 |           41 |     5 |
-
-**Write** (evutils; expelliarmus/evlib are read-only for these formats)
-
-| Format | evutils |
-| ------ | ------: |
-| EVT2   |     146 |
-| EVT2.1 |     110 |
-| EVT3   |      74 |
-
-(`–` = format not supported by that library.)
-
 
 ## Acknowledgements
 

{evutils-0.3.10 → evutils-0.3.11}/README.md

@@ -18,10 +18,12 @@ This project draws inspiration from several excellent libraries in the event-bas
 
 
 ## Installation
-We recommend installing `evutils` using `uv`.
+We recommend installing `evutils` using `uv`. 
 ### From PyPi
 ```bash
-uv add evutils[all]
+uv add evutils # Basic library
+uv add evutils[all] # All groups (pandas, numba, torch, hdf5, etc..)
+uv add evutils[dev] # Dev group
 ```
 
 ### From Git
@@ -122,26 +124,6 @@ uv run pytest benchmarks/ --benchmark-group-by=param:fmt    # compare libraries
 
 The benchmarks download a real Prophesee recording on first use. Optional cross-library comparisons run automatically once the libraries are installed (`uv pip install -e ".[compare]"`); OpenEB/Metavision is compared via the Docker image in `benchmarks/docker/`. See [`benchmarks/README.md`](benchmarks/README.md) for details.
 
-Decode/encode throughput on a 12th Gen Intel Core i7-1280P (millions of events per second, higher is better):
-
-**Read** (full-file decode)
-
-| Format | evutils | expelliarmus | evlib |
-| ------ | ------: | -----------: | ----: |
-| EVT2   |      91 |          105 |     5 |
-| EVT2.1 |      72 |            – |     – |
-| EVT3   |      53 |           41 |     5 |
-
-**Write** (evutils; expelliarmus/evlib are read-only for these formats)
-
-| Format | evutils |
-| ------ | ------: |
-| EVT2   |     146 |
-| EVT2.1 |     110 |
-| EVT3   |      74 |
-
-(`–` = format not supported by that library.)
-
 
 ## Acknowledgements
 

evutils-0.3.11/benchmarks/README.md

@@ -0,0 +1,131 @@
+# Benchmarks
+
+Read/write throughput benchmarks for the native EVT2 / EVT2.1 / EVT3 codecs, plus optional comparisons against other event libraries.
+
+These benchmarks are **not** part of the normal test run (which uses `testpaths = ["tests"]`). They must be executed explicitly from the repository root.
+
+## Quick Start
+
+Run the default suite (evutils only, plus any installed comparison libraries):
+```bash
+pytest benchmarks/
+```
+
+Run specific benchmarks:
+```bash
+pytest benchmarks/test_read.py           # just reads
+pytest benchmarks/test_write.py          # just writes
+```
+
+## Benchmark Options
+
+### Datasets
+You can benchmark against two datasets using the `--dataset` flag. The necessary files are automatically downloaded and cached on first use.
+- `--dataset small` (default): A ~1GB memory footprint dataset (hand recordings).
+- `--dataset large`: A massive multi-GB dataset designed to test the streaming and chunking capabilities of the decoders.
+
+```bash
+pytest benchmarks/ --dataset large
+```
+
+### Filtering Readers
+The benchmark tests are fully parametrized by the reader name. You can effortlessly exclude specific third-party libraries using pytest's standard `-k` flag (for example, if they are slow or misbehaving on large datasets):
+
+```bash
+pytest benchmarks/ -k "not evlib" --dataset large
+pytest benchmarks/ -k "not evlib and not openeb"
+```
+
+## File Structure
+
+| File | What it benchmarks |
+|------|--------------------|
+| `test_read.py`          | `evutils` decode throughput (evt2/evt21/evt3), asserts count vs reference |
+| `test_write.py`         | `evutils` encode throughput (payload = first 5M events of the real evt3 file) |
+| `test_fixed_formats.py` | `evutils` read/write for DAT and AER (+ expelliarmus on DAT read) |
+| `test_compare.py`       | third-party readers from `readers.py` (auto-skip if not installed) |
+| `readers.py`            | adapter registry — one entry per external library |
+
+*Note: DAT reuses the shared EVT3 reference events (its 14-bit coords fit 1280×720). AER is 9-bit and timestamp-less (GenX320-class), so it uses a separate small synthetic fixture.*
+
+## Comparing Against Other Libraries
+
+Install the optional readers and run with grouping so every library lines up per format:
+
+```bash
+pip install evutils[compare]      # expelliarmus, evlib
+pytest benchmarks/ --benchmark-group-by=param:fmt --benchmark-columns=mean,ops
+```
+
+Each library reads inside a lazy import. If a library is uninstalled or broken, its benchmarks simply **skip**. To add another library, append a `Reader(...)` entry to `readers.py`.
+
+## Benchmark Comparison (Mean Time in Seconds)
+
+### Reading
+
+| Library | EVT2 | EVT21 | EVT3 |
+|---|---|---|---|
+| **evutils** | 0.138 s | 0.070 s | 0.292 s |
+| **evlib** | 4.410 s | N/A | 4.327 s |
+| **expelliarmus** | 0.128 s | N/A | 0.341 s |
+
+### Writing
+
+| Library | EVT2 | EVT21 | EVT3 |
+|---|---|---|---|
+| **evutils** | 0.013 s | 0.028 s | 0.041 s |
+| **expelliarmus** | 0.077 s | N/A | 0.097 s |
+
+**Hardware:** 12th Gen Intel(R) Core(TM) i7-1280P | **OS:** Linux 7.1.1-3-MANJARO | **Python:** 3.12.13
+
+*Lower is better. Generated dynamically by `scripts/generate_benchmark_table.py`.*
+
+> **Note**: `tonic` is intentionally not included. It has no standalone EVT reader and reads Prophesee data through `expelliarmus` internally, so benchmarking it would just re-measure `expelliarmus`.
+
+## OpenEB / Metavision (via Docker)
+
+OpenEB isn't on PyPI and is painful to build locally, so there's an image that builds it once. Both commands must be run **from the repo root** (the build context must be the whole project so `evutils` is copied in):
+
+```bash
+# Build the image (compiles OpenEB from source + installs evutils; slow, one-time)
+docker build -t evutils-openeb -f benchmarks/docker/Dockerfile.openeb .
+
+# Run the full suite (evutils + OpenEB), grouped per format
+docker run --rm evutils-openeb
+```
+
+The container's default command is `pytest benchmarks/ --benchmark-group-by=param:fmt`, so you get `evutils` and OpenEB side by side per format.
+
+### Useful Variations
+
+Persist the downloaded recording across runs (otherwise `--rm` discards the pytest cache and it re-downloads every time):
+
+```bash
+docker run --rm -v evutils-cache:/work/.pytest_cache evutils-openeb
+```
+
+Run only the OpenEB comparison (skip the `evutils` rows):
+
+```bash
+docker run --rm evutils-openeb \
+  pytest benchmarks/test_compare.py --benchmark-group-by=param:fmt -q
+```
+
+Drop into a shell to debug the build/run:
+
+```bash
+docker run --rm -it evutils-openeb bash
+```
+
+Build a different OpenEB release if the default fails to build:
+
+```bash
+docker build -t evutils-openeb --build-arg OPENEB_VERSION=5.0.0 \
+  -f benchmarks/docker/Dockerfile.openeb .
+```
+
+### Caveats
+
+- The image targets **OpenEB 5.x on Ubuntu 22.04**; OpenEB's apt dependencies and install layout drift between releases, so the `apt-get`/`PYTHONPATH` lines may need tweaking. The Dockerfile imports `metavision_core` at build time, so a broken OpenEB install fails during `docker build` rather than silently skipping at run time.
+- The first pass is slow: it compiles OpenEB (`-j$(nproc)`) and downloads the reference recording on first run.
+- A repo-root `.dockerignore` keeps the build context small (excludes `.venv`, `build/`, `.git`, `data/`, `*.raw`, etc.).

evutils-0.3.11/benchmarks/conftest.py

@@ -0,0 +1,94 @@
+"""Benchmark fixtures.
+
+``EventFile`` and ``real_event_files`` are duplicated from ``tests/conftest.py``
+on purpose: pytest only shares conftest fixtures downward, and ``benchmarks/``
+is a sibling of ``tests/``, so there is no clean way to reuse them without a
+repo-root conftest. Keep the two copies in sync.
+"""
+import sys
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from evutils.io import EventReader
+
+sys.path.append(str(Path(__file__).parent.parent / "tests"))
+from conftest_utils import EventFile, download_and_extract_gdrive, load_event_files
+
+#: Cap on how many events are held in memory for the write benchmarks. Large
+#: enough for a stable throughput measurement, small enough to stay light.
+N_REFERENCE = 5_000_000
+
+
+@pytest.fixture(scope='session')
+def real_event_files(request, benchmark_dataset):
+    """Real Prophesee recordings (downloaded + cached on first use).
+
+    Returns ``{format: [EventFile(path, count)]}``. 
+    """
+    if benchmark_dataset == "large":
+        temp_dir = request.config.cache.mkdir("event_files_huge")
+        file_id = "1QPuilR1VD0rKyhVOlu1Y-HtkO4ZBc2Cz"
+        
+        json_files = list(temp_dir.glob("*.json"))
+        if not json_files:
+            download_and_extract_gdrive(file_id, temp_dir, "huge.tar.zst")
+            
+        return load_event_files(temp_dir)
+    else:
+        temp_dir = request.config.cache.mkdir("event_files")
+        file_id = "1uhOsWbp2o3CktsHrFkzGCNFbx0bQLsct"
+        filenames = {
+            'evt3': "hand_evt3.raw",
+            'evt21': "hand_evt21.raw",
+            'evt2': "hand_evt2.raw",
+        }
+        paths = {fmt: temp_dir / name for fmt, name in filenames.items()}
+
+        for key, path in paths.items():
+            if not path.exists():
+                download_and_extract_gdrive(file_id, temp_dir, "hand.tar.zst")
+                break
+                
+        return load_event_files(temp_dir, paths)
+
+
+@pytest.fixture(scope='session')
+def reference_events(real_event_files):
+    """First ``N_REFERENCE`` events of the real EVT3 recording as an AoS array.
+
+    Decoded once and reused as the payload for every write benchmark, so the
+    write benchmarks measure encoding cost only (not decoding).
+    """
+    parts = []
+    total = 0
+    if 'evt3' not in real_event_files or not real_event_files['evt3']:
+        pytest.skip("No evt3 files available for reference events")
+    # Use the hand_evt3.raw file for reference events
+    ef = next((f for f in real_event_files['evt3'] if 'hand' in f.path.name), real_event_files['evt3'][0])
+    with EventReader(ef.path, n_events=1_000_000) as reader:
+        for chunk in reader:
+            parts.append(chunk.to_aos())
+            total += len(chunk)
+            if total >= N_REFERENCE:
+                break
+    return np.concatenate(parts)[:N_REFERENCE]
+
+
+def pytest_addoption(parser):
+    parser.addoption(
+        "--rounds", action="store", default=4, type=int, help="Number of benchmark rounds"
+    )
+    parser.addoption(
+        "--dataset", action="store", default="small", choices=["small", "large"], 
+        help="Dataset size to use for benchmarks ('small' or 'large')"
+    )
+
+@pytest.fixture(scope="session")
+def benchmark_rounds(request):
+    return request.config.getoption("--rounds")
+
+@pytest.fixture(scope="session")
+def benchmark_dataset(request):
+    return request.config.getoption("--dataset")

evutils-0.3.11/benchmarks/docker/Dockerfile.openeb

@@ -0,0 +1,56 @@
+# OpenEB (Metavision SDK, open-source edition) + evutils, for running the
+# comparison benchmarks against OpenEB's RawReader.
+#
+# OpenEB is not on PyPI and is fiddly to build; this image does it once.
+#
+# Build (from the repo root, so the whole project is the build context):
+#     docker build -t evutils-openeb -f benchmarks/docker/Dockerfile.openeb .
+#
+# Run the benchmarks (downloads the reference recordings on first run):
+#     docker run --rm evutils-openeb
+#
+# Tip: add a repo-root .dockerignore (.venv, build/, .git, *.raw, data/) to keep
+# the build context small.
+#
+# NOTE: OpenEB's exact apt dependencies and layout shift between releases. This
+# targets OpenEB 5.x on Ubuntu 22.04 -- bump OPENEB_VERSION / tweak deps if the
+# build fails.
+FROM registry.git.ee.ethz.ch/pbl/research/event-camera/docker/open-eb-docker/openeb_base:latest
+
+ARG USERNAME=user
+ARG PASSWORD=password
+ARG USER_ID=1000
+ARG GROUP_ID=1000
+
+# Validate that all required arguments are set
+RUN : \
+  && if [ -z "$USERNAME" ]; then echo "ERROR: USERNAME is not set."; exit 1; fi \
+  && if [ -z "$PASSWORD" ]; then echo "ERROR: PASSWORD is not set."; exit 1; fi \
+  && if [ -z "$USER_ID" ]; then echo "ERROR: USER_ID is not set."; exit 1; fi \
+  && if [ -z "$GROUP_ID" ]; then echo "ERROR: GROUP_ID is not set."; exit 1; fi
+
+RUN groupadd -g ${GROUP_ID} ${USERNAME} && useradd -u ${USER_ID} -g ${GROUP_ID} -ms /bin/bash ${USERNAME} && usermod -aG sudo ${USERNAME} && echo "${USERNAME}:${PASSWORD}" | chpasswd
+
+USER ${USERNAME}
+RUN echo "source /openeb/build/utils/scripts/setup_env.sh" >> /home/${USERNAME}/.bashrc
+
+WORKDIR /home/${USERNAME}/work
+COPY . /home/${USERNAME}/work
+
+
+
+# 2. Omit --python 3.12 so it defaults to the system Python (3.10) to match OpenEB
+RUN uv venv --system-site-packages
+RUN uv pip install --no-cache-dir -e ".[test,compare]"
+
+ENV PATH="/home/${USERNAME}/work/.venv/bin:$PATH"
+
+# 3. Source the OpenEB setup script directly during the RUN step
+RUN . /openeb/build/utils/scripts/setup_env.sh && \
+    python3 -c "from metavision_core.event_io import RawReader; print('OpenEB OK')"
+
+# 4. Use an ENTRYPOINT script to ensure OpenEB vars are loaded for ANY command you run
+ENTRYPOINT ["/bin/bash", "-c", "source /openeb/build/utils/scripts/setup_env.sh && exec \"$@\"", "--"]
+
+CMD ["pytest", "benchmarks/", "--benchmark-group-by=param:fmt", \
+     "--benchmark-columns=mean,ops", "-q"]

{evutils-0.3.10 → evutils-0.3.11}/benchmarks/readers.py

@@ -42,7 +42,12 @@ def _count(obj) -> int:
 def _read_expelliarmus(path: str, fmt: str) -> int:
     # https://github.com/open-neuromorphic/expelliarmus  (evt2, evt3, dat)
     from expelliarmus import Wizard
-    return _count(Wizard(encoding=fmt).read(str(path)))
+    wiz = Wizard(encoding=fmt)
+    wiz.set_file(str(path))
+    total = 0
+    for chunk in wiz.read_chunk():
+        total += len(chunk)
+    return total
 
 
 # NOTE: tonic (https://github.com/neuromorphs/tonic) has no standalone EVT/.raw
@@ -53,11 +58,17 @@ def _read_expelliarmus(path: str, fmt: str) -> int:
 
 def _read_evlib(path: str, fmt: str) -> int:
     # https://github.com/tallamjr/evlib  (Rust-backed). Auto-detects the format;
-    # load_events() returns a polars LazyFrame, so collect() to force decoding.
+    # load_events() returns a polars LazyFrame. To avoid OOM on huge files,
+    # we use an aggregation (pl.len()) and stream it using Polars streaming engine.
     import evlib
+    import polars as pl
     df = evlib.load_events(str(path))
     if hasattr(df, "collect"):
-        df = df.collect()
+        try:
+            return df.select(pl.len()).collect(engine='streaming').item()
+        except TypeError:
+            # Fallback for older Polars versions
+            return df.select(pl.len()).collect(streaming=True).item()
     return _count(df)
 
 

{evutils-0.3.10 → evutils-0.3.11}/benchmarks/test_compare.py

@@ -21,16 +21,19 @@ from readers import ALL_FORMATS, READERS
 
 @pytest.mark.parametrize("fmt", ALL_FORMATS)
 @pytest.mark.parametrize("reader", READERS, ids=lambda r: r.name)
-def test_read_compare(benchmark, real_event_files, reader, fmt):
+def test_read_compare(benchmark, benchmark_rounds, real_event_files, reader, fmt):
     if fmt not in reader.formats:
         pytest.skip(f"{reader.name} does not support {fmt}")
 
-    ef = real_event_files[fmt]
+    benchmark.group = f"read-{fmt}"
+    if fmt not in real_event_files or not real_event_files[fmt]:
+        pytest.skip(f"No files for format {fmt}")
+    ef = next((f for f in real_event_files[fmt] if 'hand' in f.path.name), real_event_files[fmt][0])
 
     try:
         n = benchmark.pedantic(
             lambda: reader.read(ef.path, fmt),
-            rounds=3, iterations=1, warmup_rounds=1,
+            rounds=benchmark_rounds, iterations=1, warmup_rounds=1,
         )
     except ImportError as exc:
         pytest.skip(f"{reader.name} not available: {exc}")

evutils-0.3.11/benchmarks/test_fixed_formats.py

@@ -0,0 +1,119 @@
+"""Read/write throughput benchmarks for the fixed-record formats: DAT and AER.
+
+DAT reuses the shared ``reference_events`` (1280x720 fits its 14-bit coords).
+AER only has 9-bit coordinates and no timestamps, so it uses a separate small
+(GenX320-sized) synthetic fixture.
+
+    pytest benchmarks/test_fixed_formats.py
+
+The read benchmarks decode a file generated once per session; the write
+benchmarks measure encoding of the in-memory events. expelliarmus (if installed)
+is compared on the DAT read.
+"""
+import numpy as np
+import pytest
+
+from evutils.io import EventReader, EventWriter
+from evutils.types import Event_dtype
+
+AER_N = 5_000_000
+
+
+@pytest.fixture(scope="session")
+def aer_events():
+    """Small-resolution (GenX320) events for AER, which is 9-bit / timestamp-less."""
+    rng = np.random.default_rng(0)
+    ev = np.zeros(AER_N, dtype=Event_dtype)
+    ev["x"] = rng.integers(0, 320, AER_N)
+    ev["y"] = rng.integers(0, 320, AER_N)
+    ev["p"] = rng.integers(0, 2, AER_N)
+    return ev
+
+
+@pytest.fixture(scope="session")
+def dat_file(reference_events, tmp_path_factory):
+    path = tmp_path_factory.mktemp("dat") / "ref.dat"
+    with EventWriter(path) as writer:
+        writer.write(reference_events)
+    return path
+
+
+@pytest.fixture(scope="session")
+def aer_file(aer_events, tmp_path_factory):
+    path = tmp_path_factory.mktemp("aer") / "ref.aer"
+    with EventWriter(path) as writer:
+        writer.write(aer_events)
+    return path
+
+
+def _read_all(path):
+    return len(EventReader(path).read_all())
+
+
+def _write(path, events):
+    with EventWriter(path) as writer:
+        writer.write(events)
+
+
+# --------------------------------------------------------------------------- #
+# DAT
+# --------------------------------------------------------------------------- #
+@pytest.mark.benchmark(group="read-dat")
+def test_read_dat_evutils(benchmark, benchmark_rounds, dat_file):
+    n = benchmark.pedantic(lambda: _read_all(dat_file), rounds=benchmark_rounds, iterations=1, warmup_rounds=1)
+    assert n > 0
+    benchmark.extra_info.update(library="evutils", n_events=n)
+
+
+@pytest.mark.benchmark(group="read-dat")
+def test_read_dat_expelliarmus(benchmark, benchmark_rounds, dat_file):
+    try:
+        from expelliarmus import Wizard
+    except ImportError as exc:
+        pytest.skip(f"expelliarmus not available: {exc}")
+    wizard = Wizard(encoding="dat")
+    n = benchmark.pedantic(lambda: len(wizard.read(str(dat_file))),
+                           rounds=benchmark_rounds, iterations=1, warmup_rounds=1)
+    assert n > 0
+    benchmark.extra_info.update(library="expelliarmus", n_events=n)
+
+
+@pytest.mark.benchmark(group="write-dat")
+def test_write_dat_evutils(benchmark, benchmark_rounds, reference_events, tmp_path):
+    out = tmp_path / "out.dat"
+    benchmark.pedantic(lambda: _write(out, reference_events),
+                       rounds=benchmark_rounds, iterations=1, warmup_rounds=1)
+    assert len(EventReader(out).read_all()) == len(reference_events)
+    benchmark.extra_info.update(library="evutils", n_events=len(reference_events))
+
+
+@pytest.mark.benchmark(group="write-dat")
+def test_write_dat_expelliarmus(benchmark, benchmark_rounds, reference_events, tmp_path):
+    try:
+        from expelliarmus import Wizard
+    except ImportError as exc:
+        pytest.skip(f"expelliarmus not available: {exc}")
+    wizard = Wizard(encoding="dat")
+    out = tmp_path / "out.dat"
+    benchmark.pedantic(lambda: wizard.save(str(out), reference_events),
+                       rounds=benchmark_rounds, iterations=1, warmup_rounds=1)
+    assert len(wizard.read(str(out))) == len(reference_events)
+    benchmark.extra_info.update(library="expelliarmus", n_events=len(reference_events))
+
+
+# --------------------------------------------------------------------------- #
+# AER
+# --------------------------------------------------------------------------- #
+@pytest.mark.benchmark(group="read-aer")
+def test_read_aer_evutils(benchmark, benchmark_rounds, aer_file):
+    n = benchmark.pedantic(lambda: _read_all(aer_file), rounds=benchmark_rounds, iterations=1, warmup_rounds=1)
+    assert n > 0
+    benchmark.extra_info.update(library="evutils", n_events=n)
+
+
+@pytest.mark.benchmark(group="write-aer")
+def test_write_aer_evutils(benchmark, benchmark_rounds, aer_events, tmp_path):
+    out = tmp_path / "out.aer"
+    benchmark.pedantic(lambda: _write(out, aer_events),
+                       rounds=benchmark_rounds, iterations=1, warmup_rounds=1)
+    benchmark.extra_info.update(library="evutils", n_events=len(aer_events))

{evutils-0.3.10 → evutils-0.3.11}/benchmarks/test_read.py

@@ -17,16 +17,20 @@ FORMATS = ["evt3", "evt2", "evt21"]
 
 
 @pytest.mark.parametrize("fmt", FORMATS)
-def test_read_evutils(benchmark, real_event_files, fmt):
-    ef = real_event_files[fmt]
-
-    def read_all():
-        n = 0
-        for chunk in EventReader(ef.path, n_events=5_000_000):
-            n += len(chunk)
-        return n
-
-    n = benchmark.pedantic(read_all, rounds=3, iterations=1, warmup_rounds=1)
+def test_read_evutils(benchmark, benchmark_rounds, real_event_files, fmt):
+    benchmark.group = f"read-{fmt}"
+    if fmt not in real_event_files or not real_event_files[fmt]:
+        pytest.skip(f"No files for format {fmt}")
+    ef = next((f for f in real_event_files[fmt] if 'hand' in f.path.name), real_event_files[fmt][0])
+
+    def decode():
+        total = 0
+        with EventReader(ef.path) as reader:
+            for chunk in reader:
+                total += len(chunk)
+        return total
+
+    n = benchmark.pedantic(decode, rounds=benchmark_rounds, iterations=1, warmup_rounds=1)
 
     # Sanity: the benchmarked path decodes the expected number of events.
     assert n == ef.count