eegdash 0.3.5.dev87__tar.gz → 0.3.5.dev89__tar.gz

{eegdash-0.3.5.dev87/eegdash.egg-info → eegdash-0.3.5.dev89}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eegdash
-Version: 0.3.5.dev87
+Version: 0.3.5.dev89
 Summary: EEG data for machine learning
 Author-email: Young Truong <dt.young112@gmail.com>, Arnaud Delorme <adelorme@gmail.com>, Aviv Dotan <avivd220@gmail.com>, Oren Shriki <oren70@gmail.com>, Bruno Aristimunha <b.aristimunha@gmail.com>
 License-Expression: GPL-3.0-only
@@ -60,22 +60,9 @@ Requires-Dist: memory_profiler; extra == "docs"
 Requires-Dist: ipython; extra == "docs"
 Requires-Dist: lightgbm; extra == "docs"
 Provides-Extra: all
-Requires-Dist: pre-commit; extra == "all"
-Requires-Dist: pytest; extra == "all"
-Requires-Dist: pytest-cov; extra == "all"
-Requires-Dist: codecov; extra == "all"
-Requires-Dist: pytest_cases; extra == "all"
-Requires-Dist: pytest-benchmark; extra == "all"
-Requires-Dist: sphinx; extra == "all"
-Requires-Dist: sphinx_design; extra == "all"
-Requires-Dist: sphinx_gallery; extra == "all"
-Requires-Dist: sphinx_rtd_theme; extra == "all"
-Requires-Dist: pydata-sphinx-theme; extra == "all"
-Requires-Dist: sphinx-autobuild; extra == "all"
-Requires-Dist: numpydoc; extra == "all"
-Requires-Dist: memory_profiler; extra == "all"
-Requires-Dist: ipython; extra == "all"
-Requires-Dist: lightgbm; extra == "all"
+Requires-Dist: eegdash[docs]; extra == "all"
+Requires-Dist: eegdash[dev]; extra == "all"
+Requires-Dist: eegdash[tests]; extra == "all"
 Dynamic: license-file
 
 # EEG-Dash

{eegdash-0.3.5.dev87 → eegdash-0.3.5.dev89}/eegdash/__init__.py

@@ -7,4 +7,4 @@ __init__mongo_client()
 
 __all__ = ["EEGDash", "EEGDashDataset", "EEGChallengeDataset"]
 
-__version__ = "0.3.5.dev87"
+__version__ = "0.3.5.dev89"

{eegdash-0.3.5.dev87 → eegdash-0.3.5.dev89}/eegdash/api.py

@@ -591,7 +591,7 @@ class EEGDashDataset(BaseConcatDataset):
         self,
         query: dict | None = None,
         cache_dir: str = "~/eegdash_cache",
-        dataset: str | None = None,
+        dataset: str | list[str] | None = None,
         description_fields: list[str] = [
             "subject",
             "session",
@@ -669,6 +669,13 @@ class EEGDashDataset(BaseConcatDataset):
         }
         base_dataset_kwargs = {k: v for k, v in kwargs.items() if k not in query_kwargs}
 
+        # If user provided a dataset name via the dedicated parameter (and we're not
+        # loading from a local directory), treat it as a query filter. Accept str or list.
+        if data_dir is None and dataset is not None:
+            # Allow callers to pass a single dataset id (str) or a list of them.
+            # If list is provided, let _build_query_from_kwargs turn it into $in later.
+            query_kwargs.setdefault("dataset", dataset)
+
         if query and query_kwargs:
             raise ValueError(
                 "Provide either a 'query' dictionary or keyword arguments for filtering, not both."
@@ -688,15 +695,20 @@ class EEGDashDataset(BaseConcatDataset):
                 ]
             elif data_dir:
                 # This path loads from a local directory and is not affected by DB query logic
-                if isinstance(data_dir, str) or isinstance(data_dir, Path):
+                if isinstance(data_dir, (str, Path)):
                     datasets = self.load_bids_dataset(
-                        dataset=dataset,
+                        dataset=dataset
+                        if isinstance(dataset, str)
+                        else (dataset[0] if dataset else None),
                         data_dir=data_dir,
                         description_fields=description_fields,
                         s3_bucket=s3_bucket,
                         **base_dataset_kwargs,
                     )
                 else:
+                    assert dataset is not None, (
+                        "dataset must be provided when passing multiple data_dir"
+                    )
                     assert len(data_dir) == len(dataset), (
                         "Number of datasets and directories must match"
                     )
@@ -748,7 +760,7 @@ class EEGDashDataset(BaseConcatDataset):
 
     def find_datasets(
         self,
-        query: dict[str, Any],
+        query: dict[str, Any] | None,
         description_fields: list[str],
         query_kwargs: dict,
         base_dataset_kwargs: dict,

{eegdash-0.3.5.dev87 → eegdash-0.3.5.dev89}/eegdash/data_utils.py

@@ -2,6 +2,7 @@ import json
 import logging
 import os
 import re
+import traceback
 import warnings
 from pathlib import Path
 from typing import Any
@@ -66,9 +67,7 @@ class EEGDashBaseDataset(BaseDataset):
             self.s3_open_neuro = True
 
         self.filecache = self.cache_dir / record["bidspath"]
-
         self.bids_root = self.cache_dir / record["dataset"]
-
         self.bidspath = BIDSPath(
             root=self.bids_root,
             datatype="eeg",
@@ -99,6 +98,9 @@ class EEGDashBaseDataset(BaseDataset):
         )
         if not self.s3_open_neuro:
             self.s3file = re.sub(r"(^|/)ds\d{6}/", r"\1", self.s3file, count=1)
+            if self.s3file.endswith(".set"):
+                self.s3file = self.s3file[:-4] + ".bdf"
+                self.filecache = self.filecache.with_suffix(".bdf")
 
         self.filecache.parent.mkdir(parents=True, exist_ok=True)
         info = filesystem.info(self.s3file)
@@ -132,11 +134,21 @@ class EEGDashBaseDataset(BaseDataset):
             anon=True, client_kwargs={"region_name": "us-east-2"}
         )
         for i, dep in enumerate(self.bids_dependencies):
+            if not self.s3_open_neuro:
+                # fix this when our bucket is integrated into the
+                # mongodb
+                # if the file have ".set" replace to ".bdf"
+                if dep.endswith(".set"):
+                    dep = dep[:-4] + ".bdf"
+
             s3path = self.get_s3path(dep)
             if not self.s3_open_neuro:
                 dep = self.bids_dependencies_original[i]
 
             filepath = self.cache_dir / dep
+            if not self.s3_open_neuro:
+                if self.filecache.suffix == ".set":
+                    self.filecache = self.filecache.with_suffix(".bdf")
             # here, we download the dependency and it is fine
             # in the case of the competition.
             if not filepath.exists():
@@ -179,9 +191,23 @@ class EEGDashBaseDataset(BaseDataset):
             # capturing any warnings
             # to-do: remove this once is fixed on the mne-bids side.
             with warnings.catch_warnings(record=True) as w:
-                self._raw = mne_bids.read_raw_bids(
-                    bids_path=self.bidspath, verbose="ERROR"
-                )
+                try:
+                    # TO-DO: remove this once is fixed on the our side
+                    if not self.s3_open_neuro:
+                        self.bidspath = self.bidspath.update(extension=".bdf")
+
+                    self._raw = mne_bids.read_raw_bids(
+                        bids_path=self.bidspath, verbose="ERROR"
+                    )
+                except Exception as e:
+                    logger.error(
+                        f"Error while reading BIDS file: {self.bidspath}\n"
+                        "This may be due to a missing or corrupted file.\n"
+                        "Please check the file and try again."
+                    )
+                    logger.error(f"Exception: {e}")
+                    logger.error(traceback.format_exc())
+                    raise e
                 for warning in w:
                     logger.warning(
                         f"Warning while reading BIDS file: {warning.message}"
@@ -292,7 +318,6 @@ class EEGDashBaseRaw(BaseRaw):
         )
 
     def get_s3path(self, filepath):
-        print(f"Getting S3 path for {filepath}")
         return f"{self._AWS_BUCKET}/{filepath}"
 
     def _download_s3(self) -> None:
@@ -513,7 +538,6 @@ class EEGBIDSDataset:
         with os.scandir(directory) as entries:
             for entry in entries:
                 if entry.is_file() and entry.name.endswith(extension):
-                    print("Adding ", entry.path)
                     result_files.append(entry.path)
                 elif entry.is_dir():
                     # check that entry path doesn't contain any name in ignore list

eegdash-0.3.5.dev89/eegdash/dataset.py

@@ -0,0 +1,351 @@
+from pathlib import Path
+
+from .api import EEGDashDataset
+from .registry import register_openneuro_datasets
+
+RELEASE_TO_OPENNEURO_DATASET_MAP = {
+    "R11": "ds005516",
+    "R10": "ds005515",
+    "R9": "ds005514",
+    "R8": "ds005512",
+    "R7": "ds005511",
+    "R6": "ds005510",
+    "R4": "ds005508",
+    "R5": "ds005509",
+    "R3": "ds005507",
+    "R2": "ds005506",
+    "R1": "ds005505",
+}
+
+SUBJECT_MINI_RELEASE_MAP = {
+    "R11": [
+        "NDARAB678VYW",
+        "NDARAG788YV9",
+        "NDARAM946HJE",
+        "NDARAY977BZT",
+        "NDARAZ532KK0",
+        "NDARCE912ZXW",
+        "NDARCM214WFE",
+        "NDARDL033XRG",
+        "NDARDT889RT9",
+        "NDARDZ794ZVP",
+        "NDAREV869CPW",
+        "NDARFN221WW5",
+        "NDARFV289RKB",
+        "NDARFY623ZTE",
+        "NDARGA890MKA",
+        "NDARHN206XY3",
+        "NDARHP518FUR",
+        "NDARJL292RYV",
+        "NDARKM199DXW",
+        "NDARKW236TN7",
+    ],
+    "R10": [
+        "NDARAR935TGZ",
+        "NDARAV474ADJ",
+        "NDARCB869VM8",
+        "NDARCJ667UPL",
+        "NDARCM677TC1",
+        "NDARET671FTC",
+        "NDARKM061NHZ",
+        "NDARLD501HDK",
+        "NDARLL176DJR",
+        "NDARMT791WDH",
+        "NDARMW299ZAB",
+        "NDARNC405WJA",
+        "NDARNP962TJK",
+        "NDARPB967KU7",
+        "NDARRU560AGK",
+        "NDARTB173LY2",
+        "NDARUW377KAE",
+        "NDARVH565FX9",
+        "NDARVP799KGY",
+        "NDARVY962GB5",
+    ],
+    "R9": [
+        "NDARAC589YMB",
+        "NDARAC853CR6",
+        "NDARAH239PGG",
+        "NDARAL897CYV",
+        "NDARAN160GUF",
+        "NDARAP049KXJ",
+        "NDARAP457WB5",
+        "NDARAW216PM7",
+        "NDARBA004KBT",
+        "NDARBD328NUQ",
+        "NDARBF042LDM",
+        "NDARBH019KPD",
+        "NDARBH728DFK",
+        "NDARBM370JCB",
+        "NDARBU183TDJ",
+        "NDARBW971DCW",
+        "NDARBZ444ZHK",
+        "NDARCC620ZFT",
+        "NDARCD182XT1",
+        "NDARCK113CJM",
+    ],
+    "R8": [
+        "NDARAB514MAJ",
+        "NDARAD571FLB",
+        "NDARAF003VCL",
+        "NDARAG191AE8",
+        "NDARAJ977PRJ",
+        "NDARAP912JK3",
+        "NDARAV454VF0",
+        "NDARAY298THW",
+        "NDARBJ375VP4",
+        "NDARBT436PMT",
+        "NDARBV630BK6",
+        "NDARCB627KDN",
+        "NDARCC059WTH",
+        "NDARCM953HKD",
+        "NDARCN681CXW",
+        "NDARCT889DMB",
+        "NDARDJ204EPU",
+        "NDARDJ544BU5",
+        "NDARDP292DVC",
+        "NDARDW178AC6",
+    ],
+    "R7": [
+        "NDARAY475AKD",
+        "NDARBW026UGE",
+        "NDARCK162REX",
+        "NDARCK481KRH",
+        "NDARCV378MMX",
+        "NDARCX462NVA",
+        "NDARDJ970ELG",
+        "NDARDU617ZW1",
+        "NDAREM609ZXW",
+        "NDAREW074ZM2",
+        "NDARFE555KXB",
+        "NDARFT176NJP",
+        "NDARGK442YHH",
+        "NDARGM439FZD",
+        "NDARGT634DUJ",
+        "NDARHE283KZN",
+        "NDARHG260BM9",
+        "NDARHL684WYU",
+        "NDARHN224TPA",
+        "NDARHP841RMR",
+    ],
+    "R6": [
+        "NDARAD224CRB",
+        "NDARAE301XTM",
+        "NDARAT680GJA",
+        "NDARCA578CEB",
+        "NDARDZ147ETZ",
+        "NDARFL793LDE",
+        "NDARFX710UZA",
+        "NDARGE994BMX",
+        "NDARGP191YHN",
+        "NDARGV436PFT",
+        "NDARHF545HFW",
+        "NDARHP039DBU",
+        "NDARHT774ZK1",
+        "NDARJA830BYV",
+        "NDARKB614KGY",
+        "NDARKM250ET5",
+        "NDARKZ085UKQ",
+        "NDARLB581AXF",
+        "NDARNJ899HW7",
+        "NDARRZ606EDP",
+    ],
+    "R4": [
+        "NDARAC350BZ0",
+        "NDARAD615WLJ",
+        "NDARAG584XLU",
+        "NDARAH503YG1",
+        "NDARAX272ZJL",
+        "NDARAY461TZZ",
+        "NDARBC734UVY",
+        "NDARBL444FBA",
+        "NDARBT640EBN",
+        "NDARBU098PJT",
+        "NDARBU928LV0",
+        "NDARBV059CGE",
+        "NDARCG037CX4",
+        "NDARCG947ZC0",
+        "NDARCH001CN2",
+        "NDARCU001ZN7",
+        "NDARCW497XW2",
+        "NDARCX053GU5",
+        "NDARDF568GL5",
+        "NDARDJ092YKH",
+    ],
+    "R5": [
+        "NDARAH793FBF",
+        "NDARAJ689BVN",
+        "NDARAP785CTE",
+        "NDARAU708TL8",
+        "NDARBE091BGD",
+        "NDARBE103DHM",
+        "NDARBF851NH6",
+        "NDARBH228RDW",
+        "NDARBJ674TVU",
+        "NDARBM433VER",
+        "NDARCA740UC8",
+        "NDARCU633GCZ",
+        "NDARCU736GZ1",
+        "NDARCU744XWL",
+        "NDARDC843HHM",
+        "NDARDH086ZKK",
+        "NDARDL305BT8",
+        "NDARDU853XZ6",
+        "NDARDV245WJG",
+        "NDAREC480KFA",
+    ],
+    "R3": [
+        "NDARAA948VFH",
+        "NDARAD774HAZ",
+        "NDARAE828CML",
+        "NDARAG340ERT",
+        "NDARBA839HLG",
+        "NDARBE641DGZ",
+        "NDARBG574KF4",
+        "NDARBM642JFT",
+        "NDARCL016NHB",
+        "NDARCV944JA6",
+        "NDARCY178KJP",
+        "NDARDY150ZP9",
+        "NDAREC542MH3",
+        "NDAREK549XUQ",
+        "NDAREM887YY8",
+        "NDARFA815FXE",
+        "NDARFF644ZGD",
+        "NDARFV557XAA",
+        "NDARFV780ABD",
+        "NDARGB102NWJ",
+    ],
+    "R2": [
+        "NDARAB793GL3",
+        "NDARAM675UR8",
+        "NDARBM839WR5",
+        "NDARBU730PN8",
+        "NDARCT974NAJ",
+        "NDARCW933FD5",
+        "NDARCZ770BRG",
+        "NDARDW741HCF",
+        "NDARDZ058NZN",
+        "NDAREC377AU2",
+        "NDAREM500WWH",
+        "NDAREV527ZRF",
+        "NDAREV601CE7",
+        "NDARFF070XHV",
+        "NDARFR108JNB",
+        "NDARFT305CG1",
+        "NDARGA056TMW",
+        "NDARGH775KF5",
+        "NDARGJ878ZP4",
+        "NDARHA387FPM",
+    ],
+    "R1": [
+        "NDARAC904DMU",
+        "NDARAM704GKZ",
+        "NDARAP359UM6",
+        "NDARBD879MBX",
+        "NDARBH024NH2",
+        "NDARBK082PDD",
+        "NDARCA153NKE",
+        "NDARCE721YB5",
+        "NDARCJ594BWQ",
+        "NDARCN669XPR",
+        "NDARCW094JCG",
+        "NDARCZ947WU5",
+        "NDARDH670PXH",
+        "NDARDL511UND",
+        "NDARDU986RBM",
+        "NDAREM731BYM",
+        "NDAREN519BLJ",
+        "NDARFK610GY5",
+        "NDARFT581ZW5",
+        "NDARFW972KFQ",
+    ],
+}
+
+
+class EEGChallengeDataset(EEGDashDataset):
+    def __init__(
+        self,
+        release: str,
+        cache_dir: str,
+        mini: bool = True,
+        query: dict | None = None,
+        s3_bucket: str | None = "s3://nmdatasets/NeurIPS25",
+        **kwargs,
+    ):
+        """Create a new EEGDashDataset from a given query or local BIDS dataset directory
+        and dataset name. An EEGDashDataset is pooled collection of EEGDashBaseDataset
+        instances (individual recordings) and is a subclass of braindecode's BaseConcatDataset.
+
+        Parameters
+        ----------
+        release: str
+            Release name. Can be one of ["R1", ..., "R11"]
+        mini: bool, default True
+            Whether to use the mini-release version of the dataset. It is recommended
+            to use the mini version for faster training and evaluation.
+        query : dict | None
+            Optionally a dictionary that specifies a query to be executed,
+            in addition to the dataset (automatically inferred from the release argument).
+            See EEGDash.find() for details on the query format.
+        cache_dir : str
+            A directory where the dataset will be cached locally.
+        s3_bucket : str | None
+            An optional S3 bucket URI to use instead of the
+            default OpenNeuro bucket for loading data files.
+        kwargs : dict
+            Additional keyword arguments to be passed to the EEGDashDataset
+            constructor.
+
+        """
+        self.release = release
+        self.mini = mini
+
+        if release not in RELEASE_TO_OPENNEURO_DATASET_MAP:
+            raise ValueError(
+                f"Unknown release: {release}, expected one of {list(RELEASE_TO_OPENNEURO_DATASET_MAP.keys())}"
+            )
+
+        dataset_parameters = []
+        if isinstance(release, str):
+            dataset_parameters.append(RELEASE_TO_OPENNEURO_DATASET_MAP[release])
+        else:
+            raise ValueError(
+                f"Unknown release type: {type(release)}, the expected type is str."
+            )
+
+        if query and "dataset" in query:
+            raise ValueError(
+                "Query using the parameters `dataset` with the class EEGChallengeDataset is not possible."
+                "Please use the release argument instead, or the object EEGDashDataset instead."
+            )
+
+        if self.mini:
+            if query and "subject" in query:
+                raise ValueError(
+                    "Query using the parameters `subject` with the class EEGChallengeDataset and `mini==True` is not possible."
+                    "Please don't use the `subject` selection twice."
+                    "Set `mini=False` to use the `subject` selection."
+                )
+            kwargs["subject"] = SUBJECT_MINI_RELEASE_MAP[release]
+            s3_bucket = f"{s3_bucket}/{release}_mini_L100_bdf"
+        else:
+            s3_bucket = f"{s3_bucket}/{release}_L100_bdf"
+
+        super().__init__(
+            dataset=dataset_parameters,
+            query=query,
+            cache_dir=cache_dir,
+            s3_bucket=s3_bucket,
+            **kwargs,
+        )
+
+
+registered_classes = register_openneuro_datasets(
+    summary_file=Path(__file__).with_name("dataset_summary.csv"),
+    base_class=EEGDashDataset,
+    namespace=globals(),
+)
+
+
+__all__ = ["EEGChallengeDataset"] + list(registered_classes.keys())

{eegdash-0.3.5.dev87 → eegdash-0.3.5.dev89/eegdash.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eegdash
-Version: 0.3.5.dev87
+Version: 0.3.5.dev89
 Summary: EEG data for machine learning
 Author-email: Young Truong <dt.young112@gmail.com>, Arnaud Delorme <adelorme@gmail.com>, Aviv Dotan <avivd220@gmail.com>, Oren Shriki <oren70@gmail.com>, Bruno Aristimunha <b.aristimunha@gmail.com>
 License-Expression: GPL-3.0-only
@@ -60,22 +60,9 @@ Requires-Dist: memory_profiler; extra == "docs"
 Requires-Dist: ipython; extra == "docs"
 Requires-Dist: lightgbm; extra == "docs"
 Provides-Extra: all
-Requires-Dist: pre-commit; extra == "all"
-Requires-Dist: pytest; extra == "all"
-Requires-Dist: pytest-cov; extra == "all"
-Requires-Dist: codecov; extra == "all"
-Requires-Dist: pytest_cases; extra == "all"
-Requires-Dist: pytest-benchmark; extra == "all"
-Requires-Dist: sphinx; extra == "all"
-Requires-Dist: sphinx_design; extra == "all"
-Requires-Dist: sphinx_gallery; extra == "all"
-Requires-Dist: sphinx_rtd_theme; extra == "all"
-Requires-Dist: pydata-sphinx-theme; extra == "all"
-Requires-Dist: sphinx-autobuild; extra == "all"
-Requires-Dist: numpydoc; extra == "all"
-Requires-Dist: memory_profiler; extra == "all"
-Requires-Dist: ipython; extra == "all"
-Requires-Dist: lightgbm; extra == "all"
+Requires-Dist: eegdash[docs]; extra == "all"
+Requires-Dist: eegdash[dev]; extra == "all"
+Requires-Dist: eegdash[tests]; extra == "all"
 Dynamic: license-file
 
 # EEG-Dash

{eegdash-0.3.5.dev87 → eegdash-0.3.5.dev89}/eegdash.egg-info/SOURCES.txt

@@ -47,6 +47,7 @@ tests/test_dataset_registration.py
 tests/test_eegdash.py
 tests/test_functional.py
 tests/test_init.py
+tests/test_minirelease.py
 tests/test_mongo_connection.py
 tests/test_offline.py
 tests/test_query.py

{eegdash-0.3.5.dev87 → eegdash-0.3.5.dev89}/eegdash.egg-info/requires.txt

@@ -16,22 +16,9 @@ eeglabio
 tabulate
 
 [all]
-pre-commit
-pytest
-pytest-cov
-codecov
-pytest_cases
-pytest-benchmark
-sphinx
-sphinx_design
-sphinx_gallery
-sphinx_rtd_theme
-pydata-sphinx-theme
-sphinx-autobuild
-numpydoc
-memory_profiler
-ipython
-lightgbm
+eegdash[docs]
+eegdash[dev]
+eegdash[tests]
 
 [dev]
 pre-commit

{eegdash-0.3.5.dev87 → eegdash-0.3.5.dev89}/pyproject.toml

@@ -84,22 +84,9 @@ docs = [
 ]
 
 all = [
-  "pre-commit",
-  "pytest",
-  "pytest-cov",
-  "codecov",
-  "pytest_cases",
-  "pytest-benchmark",
-  "sphinx",
-  "sphinx_design",
-  "sphinx_gallery",
-  "sphinx_rtd_theme",
-  "pydata-sphinx-theme",
-  "sphinx-autobuild",
-  "numpydoc",
-  "memory_profiler",
-  "ipython",
-  "lightgbm",
+  "eegdash[docs]",
+  "eegdash[dev]",
+  "eegdash[tests]",
 ]
 
 [tool.setuptools]

{eegdash-0.3.5.dev87 → eegdash-0.3.5.dev89}/tests/test_dataset.py

@@ -16,7 +16,7 @@ CACHE_DIR.mkdir(parents=True, exist_ok=True)
 
 
 def _load_release(release):
-    ds = EEGChallengeDataset(release=release, cache_dir=CACHE_DIR)
+    ds = EEGChallengeDataset(release=release, mini=False, cache_dir=CACHE_DIR)
     getattr(ds, "description", None)
     return ds
 
@@ -31,10 +31,10 @@ def warmed_mongo():
 
 def test_eeg_challenge_dataset_initialization():
     """Test the initialization of EEGChallengeDataset."""
-    dataset = EEGChallengeDataset(release="R5", cache_dir=CACHE_DIR)
+    dataset = EEGChallengeDataset(release="R5", mini=False, cache_dir=CACHE_DIR)
 
     release = "R5"
-    expected_bucket_prefix = f"s3://nmdatasets/NeurIPS25/{release}_L100"
+    expected_bucket_prefix = f"s3://nmdatasets/NeurIPS25/{release}_L100_bdf"
     assert dataset.s3_bucket == expected_bucket_prefix, (
         f"Unexpected s3_bucket: {dataset.s3_bucket} (expected {expected_bucket_prefix})"
     )
@@ -60,7 +60,7 @@ def test_eeg_challenge_dataset_initialization():
 
 @pytest.mark.parametrize("release, number_files", RELEASE_FILES)
 def test_eeg_challenge_dataset_amount_files(release, number_files):
-    dataset = EEGChallengeDataset(release=release, cache_dir=CACHE_DIR)
+    dataset = EEGChallengeDataset(release=release, mini=False, cache_dir=CACHE_DIR)
     assert len(dataset.datasets) == number_files
 
 
@@ -88,22 +88,31 @@ def test_mongodb_load_under_sometime(release):
     assert duration < 30, f"{release} took {duration:.2f}s"
 
 
-def test_consuming_data_r5():
+@pytest.mark.parametrize("mini", [True, False])
+@pytest.mark.parametrize("release", RELEASES)
+def test_consuming_one_raw(release, mini):
+    if mini:
+        cache_dir = CACHE_DIR / "mini"
+        cache_dir.mkdir(parents=True, exist_ok=True)
+    else:
+        cache_dir = CACHE_DIR
     dataset_obj = EEGChallengeDataset(
-        release="R5",
-        query=dict(task="RestingState", subject="NDARAC350XUM"),
-        cache_dir=CACHE_DIR,
+        release=release,
+        task="RestingState",
+        cache_dir=cache_dir,
+        mini=mini,
     )
     raw = dataset_obj.datasets[0].raw
     assert raw is not None
 
 
 @pytest.mark.parametrize("eeg_dash_instance", [None, EEGDash()])
-def test_eeg_dash_integration(eeg_dash_instance):
+def test_eeg_dash_integration(eeg_dash_instance, release="R5", mini=True):
     dataset_obj = EEGChallengeDataset(
-        release="R5",
-        query=dict(task="RestingState", subject="NDARAC350XUM"),
+        release=release,
+        task="RestingState",
         cache_dir=CACHE_DIR,
+        mini=mini,
         eeg_dash_instance=eeg_dash_instance,
     )
     raw = dataset_obj.datasets[0].raw

eegdash-0.3.5.dev89/tests/test_minirelease.py

@@ -0,0 +1,112 @@
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from eegdash.dataset import EEGChallengeDataset
+
+# Shared cache directory constant for all tests in the suite.
+EEG_CHALLENGE_CACHE_DIR = (
+    Path.home() / "mne_data" / "eeg_challenge_cache" / "mini"
+).resolve()
+EEG_CHALLENGE_CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+
+@pytest.fixture(scope="session")
+def warmed_mongo():
+    """Skip tests gracefully if Mongo is not reachable."""
+    try:
+        # Lazy import to avoid circulars; constructing EEGChallengeDataset will touch DB
+        _ = EEGChallengeDataset(
+            release="R5", mini=True, cache_dir=EEG_CHALLENGE_CACHE_DIR
+        )
+    except Exception:
+        pytest.skip("Mongo not reachable")
+
+
+def test_minirelease_vs_full_counts_and_subjects(warmed_mongo):
+    """Mini release should have fewer files and (typically) fewer subjects than full release."""
+    release = "R5"
+
+    ds_mini = EEGChallengeDataset(
+        release=release, mini=True, cache_dir=EEG_CHALLENGE_CACHE_DIR
+    )
+    ds_full = EEGChallengeDataset(
+        release=release, mini=False, cache_dir=EEG_CHALLENGE_CACHE_DIR
+    )
+
+    # File count: mini must be strictly smaller than full
+    assert len(ds_mini.datasets) < len(ds_full.datasets)
+
+    # Subject cardinality: mini should be strictly less than full, and > 0
+    subj_mini = ds_mini.description["subject"].nunique()
+    subj_full = ds_full.description["subject"].nunique()
+    assert subj_mini > 0
+    assert subj_mini < subj_full
+
+
+def test_minirelease_subject_raw_equivalence(warmed_mongo):
+    """For a subject present in the mini set, loading that subject in mini vs full yields identical raw data."""
+    release = "R5"
+
+    # Pick a concrete subject from the mini set to avoid guessing
+    ds_mini_all = EEGChallengeDataset(
+        release=release, mini=True, cache_dir=EEG_CHALLENGE_CACHE_DIR
+    )
+    assert len(ds_mini_all.datasets) > 0
+    subject = ds_mini_all.description["subject"].iloc[0]
+
+    ds_mini = EEGChallengeDataset(
+        release=release, mini=True, cache_dir=EEG_CHALLENGE_CACHE_DIR, subject=subject
+    )
+    ds_full = EEGChallengeDataset(
+        release=release, mini=False, cache_dir=EEG_CHALLENGE_CACHE_DIR, subject=subject
+    )
+
+    assert len(ds_mini.datasets) > 0
+    assert len(ds_full.datasets) > 0
+
+    # Identify a common BIDS file (bidspath) present in both (bucket prefixes differ between mini/full)
+    mini_paths = {d.record["bidspath"] for d in ds_mini.datasets}
+    full_paths = {d.record["bidspath"] for d in ds_full.datasets}
+    intersection = mini_paths & full_paths
+    assert intersection, "No common recordings found for the chosen subject"
+
+    common_path = next(iter(intersection))
+    mini_idx = next(
+        i for i, d in enumerate(ds_mini.datasets) if d.record["bidspath"] == common_path
+    )
+    full_idx = next(
+        i for i, d in enumerate(ds_full.datasets) if d.record["bidspath"] == common_path
+    )
+
+    raw_mini = ds_mini.datasets[mini_idx].raw
+    raw_full = ds_full.datasets[full_idx].raw
+
+    # Basic metadata equivalence
+    assert raw_mini.info["sfreq"] == raw_full.info["sfreq"]
+    assert raw_mini.info["nchan"] == raw_full.info["nchan"]
+    assert raw_mini.ch_names == raw_full.ch_names
+
+    # Compare a small data slice to ensure content equality (avoid loading entire arrays into memory)
+    n_samples = min(1000, raw_mini.n_times, raw_full.n_times)
+    assert n_samples > 0
+    data_mini = raw_mini.get_data(picks=[0], start=0, stop=n_samples)
+    data_full = raw_full.get_data(picks=[0], start=0, stop=n_samples)
+    assert np.allclose(data_mini, data_full, rtol=1e-6, atol=0), (
+        "Raw data mismatch between mini and full"
+    )
+
+
+def test_minirelease_consume_everything(warmed_mongo):
+    """Simply try to load all data in the mini release to catch any errors."""
+    release = "R5"
+    ds_mini = EEGChallengeDataset(
+        release=release, mini=True, cache_dir=EEG_CHALLENGE_CACHE_DIR
+    )
+
+    for dataset in ds_mini.datasets:
+        raw = dataset.raw  # noqa: F841
+        description = dataset.description  # noqa: F841
+        assert raw is not None
+        assert description is not None

{eegdash-0.3.5.dev87 → eegdash-0.3.5.dev89}/tests/test_offline.py

@@ -4,7 +4,7 @@ import pytest
 
 from eegdash import EEGDash, EEGDashDataset
 
-CACHE_DIR = (Path.home() / "mne_data" / "eeg_challenge_cache").resolve()
+CACHE_DIR = (Path.home() / "mne_data" / "openneuro").resolve()
 CACHE_DIR.mkdir(parents=True, exist_ok=True)
 
 

eegdash-0.3.5.dev87/eegdash/dataset.py

@@ -1,82 +0,0 @@
-from pathlib import Path
-
-from .api import EEGDashDataset
-from .registry import register_openneuro_datasets
-
-RELEASE_TO_OPENNEURO_DATASET_MAP = {
-    "R11": "ds005516",
-    "R10": "ds005515",
-    "R9": "ds005514",
-    "R8": "ds005512",
-    "R7": "ds005511",
-    "R6": "ds005510",
-    "R4": "ds005508",
-    "R5": "ds005509",
-    "R3": "ds005507",
-    "R2": "ds005506",
-    "R1": "ds005505",
-}
-
-
-class EEGChallengeDataset(EEGDashDataset):
-    def __init__(
-        self,
-        release: str,
-        cache_dir: str,
-        query: dict | None = None,
-        s3_bucket: str | None = "s3://nmdatasets/NeurIPS25",
-        **kwargs,
-    ):
-        """Create a new EEGDashDataset from a given query or local BIDS dataset directory
-        and dataset name. An EEGDashDataset is pooled collection of EEGDashBaseDataset
-        instances (individual recordings) and is a subclass of braindecode's BaseConcatDataset.
-
-        Parameters
-        ----------
-        release: str
-            Release name. Can be one of ["R1", ..., "R11"]
-        query : dict | None
-            Optionally a dictionary that specifies a query to be executed,
-            in addition to the dataset (automatically inferred from the release argument).
-            See EEGDash.find() for details on the query format.
-        cache_dir : str
-            A directory where the dataset will be cached locally.
-        s3_bucket : str | None
-            An optional S3 bucket URI to use instead of the
-            default OpenNeuro bucket for loading data files.
-        kwargs : dict
-            Additional keyword arguments to be passed to the EEGDashDataset
-            constructor.
-
-        """
-        self.release = release
-        if release not in RELEASE_TO_OPENNEURO_DATASET_MAP:
-            raise ValueError(f"Unknown release: {release}")
-
-        dataset = RELEASE_TO_OPENNEURO_DATASET_MAP[release]
-        if query is None:
-            query = {"dataset": dataset}
-        elif "dataset" not in query:
-            query["dataset"] = dataset
-        elif query["dataset"] != dataset:
-            raise ValueError(
-                f"Query dataset {query['dataset']} does not match the release {release} "
-                f"which corresponds to dataset {dataset}."
-            )
-
-        super().__init__(
-            query=query,
-            cache_dir=cache_dir,
-            s3_bucket=f"{s3_bucket}/{release}_L100",
-            **kwargs,
-        )
-
-
-registered_classes = register_openneuro_datasets(
-    summary_file=Path(__file__).with_name("dataset_summary.csv"),
-    base_class=EEGDashDataset,
-    namespace=globals(),
-)
-
-
-__all__ = ["EEGChallengeDataset"] + list(registered_classes.keys())