evutils 0.3.7__tar.gz → 0.3.11__tar.gz

evutils-0.3.11/.github/workflows/release.yaml

@@ -0,0 +1,143 @@
+name: Release & Publish Docs
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:   # manual runs to exercise the multi-OS wheel build without releasing
+
+permissions:
+  contents: read
+  id-token: write      # Required for trusted PyPI publishing and GitHub Pages deployment
+  pages: write         # Required for GitHub Pages deployment
+
+jobs:
+  # Gate everything on the test suite -- no wheels/sdist/publish unless it passes.
+  test:
+    name: Tests
+    uses: ./.github/workflows/test.yaml
+
+  build_wheels:
+    name: Wheels (${{ matrix.os }})
+    needs: test
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        # linux x86_64 + arm64 | windows amd64 | macOS (arm64 runner builds both
+        # arm64 natively and x86_64 via cross-compile -- see CIBW_ARCHS_MACOS).
+        os: [ubuntu-latest, ubuntu-24.04-arm, windows-latest, macos-14]
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v7
+        with:
+          submodules: recursive
+
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+
+      - name: Build wheels (cibuildwheel)
+        run: pipx run cibuildwheel --output-dir wheelhouse
+        env:
+          # requires-python (>=3.10) limits the CPython versions built. Skip
+          # musllinux, the 32-bit Windows build (win32 has no SIMD path and no
+          # numeric-stack wheels), and the free-threaded (cp*t) builds -> standard
+          # 64-bit CPython 3.10-3.14 manylinux/macos/win wheels.
+          CIBW_SKIP: "*musllinux* *-win32 cp3*t-*"
+          # Build both macOS arches on the arm64 runner (x86_64 is cross-compiled;
+          # its wheels can't be test-run here, which is fine -- we don't run tests
+          # in cibuildwheel). Ignored on Linux/Windows.
+          CIBW_ARCHS_MACOS: "x86_64 arm64"
+
+      - name: Upload wheels
+        uses: actions/upload-artifact@v7
+        with:
+          name: dist-${{ matrix.os }}
+          path: wheelhouse/*.whl
+
+  build_sdist:
+    name: Source distribution
+    needs: test
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v7
+        with:
+          submodules: recursive
+
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+
+      - name: Build sdist
+        run: pipx run build --sdist
+
+      - name: Upload sdist
+        uses: actions/upload-artifact@v7
+        with:
+          name: dist-sdist
+          path: dist/*.tar.gz
+
+  publish_pypi:
+    name: Publish to PyPI
+    needs: [build_wheels, build_sdist]
+    runs-on: ubuntu-latest
+    if: github.event_name == 'release'
+    steps:
+      - name: Download all distributions
+        uses: actions/download-artifact@v4
+        with:
+          path: dist
+          pattern: dist-*
+          merge-multiple: true
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+
+  build_and_publish_docs:
+    name: Build & Publish Sphinx Docs
+    needs: test
+    runs-on: ubuntu-latest
+    if: github.event_name == 'release'
+    # deploy-pages@v4 requires the deploying job to target the github-pages environment.
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    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: true
+
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+
+      - name: Install package and docs dependencies
+        # uv compiles the C extension locally and installs dependencies instantly
+        run: uv pip install --system .[docs]
+
+      - name: Build Sphinx HTML
+        run: |
+          cd docs
+          make html
+
+      - name: Setup GitHub Pages
+        uses: actions/configure-pages@v6
+
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v5
+        with:
+          path: 'docs/build/html'
+
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v5

{evutils-0.3.7 → evutils-0.3.11}/.github/workflows/test.yaml

@@ -5,6 +5,7 @@ on:
     branches: [main, feature/*, fix/*]
   pull_request:
     branches: [main, feature/*, fix/*]
+  workflow_call:   # allow other workflows (e.g. release) to gate on the tests
 
 jobs:
   test:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: evutils
-Version: 0.3.7
+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.7 → 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.7 → 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.7 → 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}")