evutils 0.3.11__tar.gz → 0.3.13__tar.gz

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

@@ -1,5 +1,9 @@
 name: Release & Publish Docs
 
+concurrency:
+  group: release-pages-${{ github.ref }}
+  cancel-in-progress: false
+
 on:
   release:
     types: [published]
@@ -141,3 +145,52 @@ jobs:
       - name: Deploy to GitHub Pages
         id: deployment
         uses: actions/deploy-pages@v5
+
+  test_pypi_wheels:
+    name: Test PyPI Wheel (${{ matrix.os }}, Py ${{ matrix.python }})
+    needs: publish_pypi
+    runs-on: ${{ matrix.os }}
+    if: github.event_name == 'release'
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, ubuntu-24.04-arm, windows-latest, macos-14]
+        python: ["3.10", "3.11", "3.12", "3.13", "3.14"]
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v7
+        with:
+          submodules: recursive
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v8.2.0
+        with:
+          enable-cache: false
+
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: ${{ matrix.python }}
+
+      - name: Install evutils from PyPI
+        shell: bash
+        run: |
+          # Retry loop to wait for PyPI index to update with the new release
+          # GITHUB_REF_NAME contains the tag name (e.g. v1.0.0). We strip the 'v' for pip.
+          VERSION=${GITHUB_REF_NAME#v}
+          for i in {1..12}; do
+            uv pip install --system "evutils[test]==$VERSION" --no-cache && break
+            echo "Waiting for PyPI index..."
+            sleep 10
+          done
+
+      - name: Remove local source tree
+        shell: bash
+        run: |
+          # Remove local source so Python is forced to import from the installed PyPI wheel
+          rm -rf src/evutils
+
+      - name: Run tests against PyPI wheel
+        shell: bash
+        run: |
+          python -m pytest -s -v tests/

{evutils-0.3.11 → evutils-0.3.13}/CMakeLists.txt

@@ -40,8 +40,8 @@ endif()
 # ctypes loader finds it next to evutils/__init__.py.
 if(DEFINED SKBUILD_PROJECT_NAME)
   install(TARGETS evutils_native
-          LIBRARY DESTINATION "${SKBUILD_PROJECT_NAME}"
-          RUNTIME DESTINATION "${SKBUILD_PROJECT_NAME}")
+          LIBRARY DESTINATION "${SKBUILD_PROJECT_NAME}/io"
+          RUNTIME DESTINATION "${SKBUILD_PROJECT_NAME}/io")
 else()
   # Standalone `cmake --build build` leaves the .so in build/ where the
   # loader's dev-mode search also looks.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: evutils
-Version: 0.3.11
+Version: 0.3.13
 Summary: Utilities for event-based vision
 Keywords: events,dvs,neuromorphic,vision,event-based
 Author-Email: Jakub Mandula <jakub.mandula@pbl.ee.ethz.ch>
@@ -31,6 +31,9 @@ Requires-Python: >=3.10
 Requires-Dist: numpy>=2.0.0
 Requires-Dist: opencv-python>=4.2
 Requires-Dist: numba>=0.57
+Provides-Extra: aedat
+Requires-Dist: lz4>=4.0; extra == "aedat"
+Requires-Dist: zstandard>=0.22; python_version < "3.14" and extra == "aedat"
 Provides-Extra: pandas
 Requires-Dist: pandas>=2.3.3; extra == "pandas"
 Provides-Extra: torch
@@ -46,10 +49,12 @@ Requires-Dist: tqdm>=4.41; extra == "vis"
 Provides-Extra: test
 Requires-Dist: pytest>=9.0.2; extra == "test"
 Requires-Dist: pytest-benchmark>=5.2.3; extra == "test"
+Requires-Dist: zstandard>=0.22; python_version < "3.14" and extra == "test"
 Provides-Extra: compare
 Requires-Dist: expelliarmus>=1.1.0; 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"
+Requires-Dist: evt3>=0.3; extra == "compare"
 Provides-Extra: docs
 Requires-Dist: sphinx>=8.0.0; extra == "docs"
 Requires-Dist: sphinx-autoapi>=3.6.1; extra == "docs"
@@ -59,7 +64,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,pandas,torch,vis]; extra == "all"
+Requires-Dist: evutils[aedat,hdf5,pandas,torch,vis]; extra == "all"
 Provides-Extra: dev
 Requires-Dist: evutils[all,docs,test]; extra == "dev"
 Description-Content-Type: text/markdown
@@ -69,7 +74,13 @@ Description-Content-Type: text/markdown
 [![Test](https://github.com/mandulaj/evutils/actions/workflows/test.yaml/badge.svg)](https://github.com/mandulaj/evutils/actions/workflows/test.yaml)
 
 ## Overview
-EV-Utils (``evutils``) is a performant collection of utilities for working with event-based vision data. Built with minimal dependencies, it relies on compiled C backed for speed while offering a clean, modular Python interface.
+EV-Utils (`evutils`) is a performant collection of utilities for working with event-based vision data. Built with minimal dependencies, it relies on a compiled C backend for speed while offering a clean, modular Python interface.
+
+### Core Philosophy
+* **Fast & Lightweight:** Highly optimized C parsers for zero-bottleneck data ingestion.
+* **Minimal Footprint:** Core features run entirely on NumPy and Numba.
+* **Lazy Loading:** All heavy integrations (PyTorch, Pandas, HDF5, Polars, etc.) are lazy-loaded. If you don't use them, you don't need them installed, and they won't slow down import times.
+* **Simple & Extensible:** Clean modular APIs.
 
 
 
@@ -80,6 +91,8 @@ This project draws inspiration from several excellent libraries in the event-bas
 * [event_utils](https://github.com/TimoStoff/event_utils)
 * [evlib](https://github.com/tallamjr/evlib)
 * [expelliarmus](https://github.com/open-neuromorphic/expelliarmus)
+* [event-vision-library](https://github.com/shiba24/event-vision-library)
+* [evt3](https://github.com/muthmann/evt3)
 * [openeb](https://github.com/prophesee-ai/openeb)
 
 
@@ -134,6 +147,20 @@ Wrappers for various dataset loaders -->
 
 The `io` module provides methods for reading and writing events into various event formats. It provides a simple `.read()` and `.write()` interface as well as more advanced interfaces using iterators and slicing.
 
+Supported formats (see the [formats documentation](https://mandulaj.github.io/evutils/formats.html) for details):
+
+| Format | Extensions | Read | Write | Notes |
+|---|---|:---:|:---:|---|
+| EVT3 / EVT2.1 / EVT2 (Prophesee RAW) | `.raw`, `.evt*` | ✅ | ✅ | native C decoder, external triggers |
+| DAT (Prophesee) | `.dat` | ✅ | ✅ | native C decoder |
+| AER (Prophesee) | `.aer` | ✅ | ✅ | timestamp generation selectable |
+| AEDAT 1.0 / 2.0 / 3.1 / 4.0 | `.aedat`, `.aedat4` | ✅ | 🚧 | AEDAT4 compression: `evutils[aedat]` |
+| HDF5 (DSEC/RVT layout) | `.h5`, `.hdf5` | ✅ | ✅ | `evutils[hdf5]`, ms-index random access |
+| HDF5 (Prophesee layout) | `.h5`, `.hdf5` | ✅ | 🚧 | ECF-compressed files need the ECF plugin |
+| NPZ | `.npz` | ✅ | ✅ | streaming, `np.load`-compatible |
+| CSV / TXT | `.csv`, `.txt` | ✅ | ✅ | `evutils[pandas]` |
+| BIN | `.bin` | 🚧 | 🚧 | planned |
+
 ```python
 from evutils.io import EventReader
 
@@ -191,6 +218,18 @@ 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.
 
 
+
+## & Roadmap
+We aim for universal event format support, prioritizing blazing fast read/write speeds, completeness, and extensibility. 
+- [x] Universal format support (`.raw`, `.evt2`, `.dat`, `.aedat4`, `.hdf5`, `.npz`, `.csv`, etc.)
+- [x] Full Read/Write parity where possible
+- [x] Chunked & Streaming access
+- [x] External trigger data parsing
+- [ ] **Random access / Timestamp indexing** (Big TODO for the future)
+- [ ] **Arbitrary input sources:** memory-mapped IO, pure in-memory streams, HTTP streams
+- [ ] **On-the-fly Compression wrappers:** passing file handles through `zstd` or `lz4` compression transparently before decoding
+
+
 ## Acknowledgements
 
 Thanks to all the contributors for supporting this project:

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

@@ -3,7 +3,13 @@
 [![Test](https://github.com/mandulaj/evutils/actions/workflows/test.yaml/badge.svg)](https://github.com/mandulaj/evutils/actions/workflows/test.yaml)
 
 ## Overview
-EV-Utils (``evutils``) is a performant collection of utilities for working with event-based vision data. Built with minimal dependencies, it relies on compiled C backed for speed while offering a clean, modular Python interface.
+EV-Utils (`evutils`) is a performant collection of utilities for working with event-based vision data. Built with minimal dependencies, it relies on a compiled C backend for speed while offering a clean, modular Python interface.
+
+### Core Philosophy
+* **Fast & Lightweight:** Highly optimized C parsers for zero-bottleneck data ingestion.
+* **Minimal Footprint:** Core features run entirely on NumPy and Numba.
+* **Lazy Loading:** All heavy integrations (PyTorch, Pandas, HDF5, Polars, etc.) are lazy-loaded. If you don't use them, you don't need them installed, and they won't slow down import times.
+* **Simple & Extensible:** Clean modular APIs.
 
 
 
@@ -14,6 +20,8 @@ This project draws inspiration from several excellent libraries in the event-bas
 * [event_utils](https://github.com/TimoStoff/event_utils)
 * [evlib](https://github.com/tallamjr/evlib)
 * [expelliarmus](https://github.com/open-neuromorphic/expelliarmus)
+* [event-vision-library](https://github.com/shiba24/event-vision-library)
+* [evt3](https://github.com/muthmann/evt3)
 * [openeb](https://github.com/prophesee-ai/openeb)
 
 
@@ -68,6 +76,20 @@ Wrappers for various dataset loaders -->
 
 The `io` module provides methods for reading and writing events into various event formats. It provides a simple `.read()` and `.write()` interface as well as more advanced interfaces using iterators and slicing.
 
+Supported formats (see the [formats documentation](https://mandulaj.github.io/evutils/formats.html) for details):
+
+| Format | Extensions | Read | Write | Notes |
+|---|---|:---:|:---:|---|
+| EVT3 / EVT2.1 / EVT2 (Prophesee RAW) | `.raw`, `.evt*` | ✅ | ✅ | native C decoder, external triggers |
+| DAT (Prophesee) | `.dat` | ✅ | ✅ | native C decoder |
+| AER (Prophesee) | `.aer` | ✅ | ✅ | timestamp generation selectable |
+| AEDAT 1.0 / 2.0 / 3.1 / 4.0 | `.aedat`, `.aedat4` | ✅ | 🚧 | AEDAT4 compression: `evutils[aedat]` |
+| HDF5 (DSEC/RVT layout) | `.h5`, `.hdf5` | ✅ | ✅ | `evutils[hdf5]`, ms-index random access |
+| HDF5 (Prophesee layout) | `.h5`, `.hdf5` | ✅ | 🚧 | ECF-compressed files need the ECF plugin |
+| NPZ | `.npz` | ✅ | ✅ | streaming, `np.load`-compatible |
+| CSV / TXT | `.csv`, `.txt` | ✅ | ✅ | `evutils[pandas]` |
+| BIN | `.bin` | 🚧 | 🚧 | planned |
+
 ```python
 from evutils.io import EventReader
 
@@ -125,6 +147,18 @@ 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.
 
 
+
+## & Roadmap
+We aim for universal event format support, prioritizing blazing fast read/write speeds, completeness, and extensibility. 
+- [x] Universal format support (`.raw`, `.evt2`, `.dat`, `.aedat4`, `.hdf5`, `.npz`, `.csv`, etc.)
+- [x] Full Read/Write parity where possible
+- [x] Chunked & Streaming access
+- [x] External trigger data parsing
+- [ ] **Random access / Timestamp indexing** (Big TODO for the future)
+- [ ] **Arbitrary input sources:** memory-mapped IO, pure in-memory streams, HTTP streams
+- [ ] **On-the-fly Compression wrappers:** passing file handles through `zstd` or `lz4` compression transparently before decoding
+
+
 ## Acknowledgements
 
 Thanks to all the contributors for supporting this project:

{evutils-0.3.11 → evutils-0.3.13}/benchmarks/README.md

@@ -40,13 +40,13 @@ pytest benchmarks/ -k "not evlib and not openeb"
 
 | File | What it benchmarks |
 |------|--------------------|
-| `test_read.py`          | `evutils` decode throughput (evt2/evt21/evt3), asserts count vs reference |
+| `test_read.py`          | `evutils` decode throughput on the full real recordings (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) |
+| `test_formats.py`       | **uniform per-format read/write**: the same 5M real events transcoded into every format (EVT3/EVT2.1/EVT2, DAT, AER, NPZ, HDF5, CSV, AEDAT4), so numbers are comparable across formats; expelliarmus (DAT) and evlib (HDF5, AEDAT4) compared on the identical files |
+| `test_compare.py`       | third-party readers from `readers.py` on the full real recordings (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.*
+*Note: in `test_formats.py` AER is the one lossy transcode — the format has no timestamps and 9-bit coordinates, so the same events are written with coordinates masked to 0–511 (identical event count).*
 
 ## Comparing Against Other Libraries
 
@@ -98,10 +98,24 @@ The container's default command is `pytest benchmarks/ --benchmark-group-by=para
 
 ### Useful Variations
 
-Persist the downloaded recording across runs (otherwise `--rm` discards the pytest cache and it re-downloads every time):
+The recordings are **not** baked into the image (`.dockerignore` excludes the
+data and cache directories), so the fixture tries to download them on first
+use. If the container has no network access, mount the host's already-cached
+recordings and point `EVUTILS_BENCH_DATA` at them:
 
 ```bash
-docker run --rm -v evutils-cache:/work/.pytest_cache evutils-openeb
+# after benchmarks have run at least once on the host:
+docker run --rm \
+  -v "$(pwd)/.pytest_cache/d/event_files:/data:ro" \
+  -e EVUTILS_BENCH_DATA=/data \
+  evutils-openeb
+```
+
+Alternatively, persist the container's own download across runs with a named
+volume (note the workdir is `/home/user/work`):
+
+```bash
+docker run --rm -v evutils-cache:/home/user/work/.pytest_cache evutils-openeb
 ```
 
 Run only the OpenEB comparison (skip the `evutils` rows):

evutils-0.3.13/benchmarks/conftest.py

@@ -0,0 +1,171 @@
+"""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 typing import Any, cast
+
+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  # type: ignore
+
+#: 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: Any, benchmark_dataset: str) -> dict[str, list[Any]]:
+    """Real Prophesee recordings (downloaded + cached on first use).
+
+    Returns ``{format: [EventFile(path, count)]}``.
+
+    Set ``EVUTILS_BENCH_DATA`` to a directory that already contains the
+    extracted recordings (+ JSON metadata) to skip the download entirely --
+    useful in offline environments such as the OpenEB benchmark container
+    (mount the host cache there).
+    """
+    import os
+    override = os.environ.get("EVUTILS_BENCH_DATA")
+    if override:
+        data_dir = Path(override)
+        if not data_dir.is_dir():
+            pytest.skip(f"EVUTILS_BENCH_DATA={override} is not a directory")
+        return cast(dict[str, list[Any]], load_event_files(data_dir))
+
+    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 cast(dict[str, list[Any]], 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 cast(dict[str, list[Any]], load_event_files(temp_dir))
+
+
+@pytest.fixture(scope='session')
+def reference_events(real_event_files: dict[str, list[Any]]) -> Any:
+    """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: Any) -> None:
+    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: Any) -> int:
+    return int(request.config.getoption("--rounds"))
+
+@pytest.fixture(scope="session")
+def benchmark_dataset(request: Any) -> str:
+    return str(request.config.getoption("--dataset"))
+
+
+@pytest.hookimpl(hookwrapper=True)
+def pytest_benchmark_group_stats(config: Any, benchmarks: list[dict[str, Any]], group_by: str) -> Any:
+    """Guard against a pytest-benchmark crash with ``--benchmark-group-by=param:<name>``.
+
+    Benchmarks collected from non-parametrized tests have ``params = None``,
+    which the plugin's param-grouping code cannot handle (TypeError) -- and the
+    crash also swallows the whole error/summary report. Give such benchmarks an
+    explicit null param instead, so they group under ``<name>=None``.
+    """
+    if isinstance(group_by, str) and group_by.startswith("param:"):
+        names = group_by.split(":", 1)[1].split(",")
+        for bench in benchmarks:
+            if bench.get("params") is None:
+                bench["params"] = {}
+            for name in names:
+                bench["params"].setdefault(name, None)
+    yield
+
+
+@pytest.fixture(scope="session")
+def uniform_files(reference_events: Any, tmp_path_factory: Any) -> dict[str, Any]:
+    """The same ``N_REFERENCE`` real events transcoded into every format.
+
+    All per-format read/write benchmarks (benchmarks/test_formats.py) operate
+    on these files, so throughput numbers are comparable across formats: same
+    events, same count. AER is the one lossy exception -- it has no timestamps
+    and 9-bit coordinates, so its file carries the same events with coordinates
+    masked to 0..511 (the event count is identical).
+    """
+    from evutils.io import EventWriter
+
+    sys.path.append(str(Path(__file__).parent.parent / "tests"))
+    from aedat_synth import make_aedat4  # type: ignore
+
+    d = tmp_path_factory.mktemp("uniform")
+    ev = reference_events
+    files = {}
+
+    for fmt in ("evt3", "evt21", "evt2"):
+        files[fmt] = d / f"ref_{fmt}.raw"
+        with EventWriter(files[fmt], width=1280, height=720, format=fmt) as w:
+            w.write(ev)
+
+    for fmt, name in (("dat", "ref.dat"), ("npz", "ref.npz"),
+                      ("hdf5", "ref.h5"), ("csv", "ref.csv")):
+        files[fmt] = d / name
+        with EventWriter(files[fmt], width=1280, height=720) as w:
+            w.write(ev)
+
+    aer = ev.copy()
+    aer["x"] &= 0x1FF
+    aer["y"] &= 0x1FF
+    files["aer"] = d / "ref.aer"
+    with EventWriter(files["aer"]) as w:
+        w.write(aer)
+
+    files["aedat4"] = d / "ref.aedat4"
+    files["aedat4"].write_bytes(
+        make_aedat4(ev["t"], ev["x"], ev["y"], ev["p"], events_per_packet=65536)
+    )
+    return files

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

@@ -12,7 +12,7 @@ helper below; the benchmark harness stays the same.
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Callable
+from typing import Any, Callable
 
 ALL_FORMATS = ("evt3", "evt2", "evt21")
 
@@ -20,7 +20,7 @@ ALL_FORMATS = ("evt3", "evt2", "evt21")
 _CHUNK = 5_000_000
 
 
-def _count(obj) -> int:
+def _count(obj: Any) -> int:
     """Best-effort event count across the return types the libraries use
     (numpy structured array, polars DataFrame, dict of columns, ...)."""
     try:
@@ -39,15 +39,29 @@ def _count(obj) -> int:
 # --------------------------------------------------------------------------- #
 # Per-library read helpers: (path, fmt) -> event count
 # --------------------------------------------------------------------------- #
-def _read_expelliarmus(path: str, fmt: str) -> int:
+def _read_expelliarmus(path: str, fmt: str) -> tuple[int, int]:
     # https://github.com/open-neuromorphic/expelliarmus  (evt2, evt3, dat)
+    from expelliarmus import Wizard  # type: ignore
+    import numpy as np
+    wiz = Wizard(encoding=fmt)
+    wiz.set_file(str(path))
+    arr = wiz.read()
+    total = len(arr)
+    n_pos = int(np.count_nonzero(arr['p'] == 1))
+    return total, n_pos
+
+
+def _read_expelliarmus_chunked(path: str, fmt: str) -> tuple[int, int]:
     from expelliarmus import Wizard
+    import numpy as np
     wiz = Wizard(encoding=fmt)
     wiz.set_file(str(path))
     total = 0
+    n_pos = 0
     for chunk in wiz.read_chunk():
         total += len(chunk)
-    return total
+        n_pos += int(np.count_nonzero(chunk['p'] == 1))
+    return total, n_pos
 
 
 # NOTE: tonic (https://github.com/neuromorphs/tonic) has no standalone EVT/.raw
@@ -56,44 +70,75 @@ def _read_expelliarmus(path: str, fmt: str) -> int:
 # without the torchdata overhead), so it is intentionally not registered.
 
 
-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. 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"):
-        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)
+def _read_evlib(path: str, fmt: str) -> tuple[int, int]:
+    # https://github.com/tallamjr/evlib  (Rust-backed). Auto-detects the format.
+    import evlib  # type: ignore
+    import polars as pl  # type: ignore
+    import numpy as np
+    lf = evlib.load_events(str(path))
+    df = lf.collect(engine="streaming")
+    total = len(df)
+    p_array = df["polarity"].to_numpy()
+    n_pos = int(np.sum(p_array == 1))
+    return total, n_pos
 
 
-def _read_openeb(path: str, fmt: str) -> int:
+def _read_openeb(path: str, fmt: str) -> tuple[int, int]:
     # OpenEB / Metavision SDK (not on PyPI -- see benchmarks/docker).
-    from metavision_core.event_io import RawReader
+    from metavision_core.event_io import RawReader  # type: ignore
+    import numpy as np
     reader = RawReader(str(path))
     n = 0
+    n_pos = 0
     while not reader.is_done():
-        n += len(reader.load_n_events(_CHUNK))
-    return n
+        chunk = reader.load_n_events(_CHUNK)
+        n += len(chunk)
+        if len(chunk) > 0:
+            n_pos += int(np.count_nonzero(chunk['p']))
+    return n, n_pos
+
+
+def _read_evt3(path: str, fmt: str) -> tuple[int, int]:
+    import evt3  # type: ignore
+    import numpy as np
+    if fmt != "evt3":
+        raise ValueError(f"evt3 package does not support {fmt}")
+    events = evt3.decode_file(str(path))
+    total = len(events)
+    n_pos = int(np.count_nonzero(events.p))
+    return total, n_pos
+
+
+def _read_event_vision_library(path: str, fmt: str) -> tuple[int, int]:
+    # event-vision-library by shiba24 (installs as evlib, shadows Rust evlib)
+    import evlib.codec.fileformat as ff  # type: ignore
+    import numpy as np
+    if fmt != "evt3":
+        raise ValueError(f"event-vision-library benchmark snippet only supports evt3")
+    it = ff.IteratorEvt3Event(str(path))
+    total = 0
+    n_pos = 0
+    for chunk in it:
+        total += len(chunk.x)
+        n_pos += int(np.sum(chunk.p))
+    return total, n_pos
 
 
 @dataclass(frozen=True)
 class Reader:
     name: str
-    formats: tuple            # subset of ALL_FORMATS this library can read
-    read: Callable[[str, str], int]
+    formats: tuple[str, ...]            # subset of ALL_FORMATS this library can read
+    read: Callable[[str, str], tuple[int, int]]
 
 
 #: Third-party readers benchmarked against evutils. evutils itself is measured
 #: separately in test_read.py; with ``--benchmark-group-by=param:fmt`` all rows
 #: for a given format line up in one table.
 READERS = [
-    Reader("expelliarmus", ("evt2", "evt3"), _read_expelliarmus),
+    Reader("expelliarmus-read_all", ("evt2", "evt3"), _read_expelliarmus),
+    Reader("expelliarmus-chunked", ("evt2", "evt3"), _read_expelliarmus_chunked),
     Reader("evlib", ("evt2", "evt3"), _read_evlib),
     Reader("openeb", ALL_FORMATS, _read_openeb),
+    Reader("evt3", ("evt3",), _read_evt3),
+    Reader("event-vision-library", ("evt3",), _read_event_vision_library),
 ]

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

@@ -16,12 +16,14 @@ it appears in the same grouped table as the readers below.
 """
 import pytest
 
-from readers import ALL_FORMATS, READERS
+from typing import Any
+
+from readers import ALL_FORMATS, READERS  # type: ignore
 
 
 @pytest.mark.parametrize("fmt", ALL_FORMATS)
 @pytest.mark.parametrize("reader", READERS, ids=lambda r: r.name)
-def test_read_compare(benchmark, benchmark_rounds, real_event_files, reader, fmt):
+def test_read_compare(benchmark: Any, benchmark_rounds: int, real_event_files: dict[str, list[Any]], reader: Any, fmt: str) -> None:
     if fmt not in reader.formats:
         pytest.skip(f"{reader.name} does not support {fmt}")
 
@@ -31,7 +33,7 @@ def test_read_compare(benchmark, benchmark_rounds, real_event_files, reader, 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(
+        n, n_pos = benchmark.pedantic(
             lambda: reader.read(ef.path, fmt),
             rounds=benchmark_rounds, iterations=1, warmup_rounds=1,
         )
@@ -39,4 +41,4 @@ def test_read_compare(benchmark, benchmark_rounds, real_event_files, reader, fmt
         pytest.skip(f"{reader.name} not available: {exc}")
 
     assert n > 0
-    benchmark.extra_info.update(library=reader.name, fmt=fmt, n_events=n)
+    benchmark.extra_info.update(library=reader.name, fmt=fmt, n_events=n, n_pos=n_pos)