eegdash 0.3.2.dev54__tar.gz → 0.3.3__tar.gz

{eegdash-0.3.2.dev54 → eegdash-0.3.3}/PKG-INFO

@@ -1,35 +1,11 @@
 Metadata-Version: 2.4
 Name: eegdash
-Version: 0.3.2.dev54
+Version: 0.3.3
 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: GNU General Public License
-        
-        Copyright (C) 2024-2025
-        
-        Young Truong, UCSD, dt.young112@gmail.com
-        Arnaud Delorme, UCSD, adelorme@ucsd.edu
-        Aviv Dotan, BGU, avivdot@bgu.post.ac.il
-        Oren Shriki, BGU, shrikio@bgu.ac.il
-        Bruno Aristimunha, b.aristimunha@gmail.com
-        
-        This program is free software; you can redistribute it and/or modify
-        it under the terms of the GNU General Public License as published by
-        the Free Software Foundation; either version 2 of the License, or
-        (at your option) any later version.
-        
-        This program is distributed in the hope that it will be useful,
-        but WITHOUT ANY WARRANTY; without even the implied warranty of
-        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-        GNU General Public License for more details.
-        
-        You should have received a copy of the GNU General Public License
-        along with this program; if not, write to the Free Software
-        Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1.07  USA
-        
+License-Expression: GPL-3.0-only
 Project-URL: Homepage, https://github.com/sccn/EEG-Dash-Data
 Project-URL: Issues, https://github.com/sccn/EEG-Dash-Data/issues
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Intended Audience :: Science/Research
 Classifier: Intended Audience :: Developers
@@ -60,6 +36,8 @@ Requires-Dist: s3fs
 Requires-Dist: scipy
 Requires-Dist: tqdm
 Requires-Dist: xarray
+Requires-Dist: h5io>=0.2.4
+Requires-Dist: pymatreader
 Provides-Extra: tests
 Requires-Dist: pytest; extra == "tests"
 Requires-Dist: pytest-cov; extra == "tests"

{eegdash-0.3.2.dev54 → eegdash-0.3.3}/eegdash/__init__.py

@@ -4,5 +4,7 @@ from .utils import __init__mongo_client
 
 __init__mongo_client()
 
+
 __all__ = ["EEGDash", "EEGDashDataset", "EEGChallengeDataset"]
-__version__ = "0.3.2.dev54"
+
+__version__ = "0.3.3"

{eegdash-0.3.2.dev54 → eegdash-0.3.3}/eegdash/api.py

@@ -534,6 +534,7 @@ class EEGDashDataset(BaseConcatDataset):
         ],
         cache_dir: str = "~/eegdash_cache",
         s3_bucket: str | None = None,
+        eeg_dash_instance=None,
         **kwargs,
     ):
         """Create a new EEGDashDataset from a given query or local BIDS dataset directory
@@ -568,29 +569,51 @@ class EEGDashDataset(BaseConcatDataset):
         """
         self.cache_dir = cache_dir
         self.s3_bucket = s3_bucket
-        if query:
-            datasets = self.find_datasets(query, description_fields, **kwargs)
-        elif data_dir:
-            if isinstance(data_dir, str):
-                datasets = self.load_bids_dataset(
-                    dataset, data_dir, description_fields, s3_bucket
-                )
+        self.eeg_dash = eeg_dash_instance or EEGDash()
+        _owns_client = eeg_dash_instance is None
+
+        try:
+            if query:
+                datasets = self.find_datasets(query, description_fields, **kwargs)
+            elif data_dir:
+                if isinstance(data_dir, str):
+                    datasets = self.load_bids_dataset(
+                        dataset, data_dir, description_fields, s3_bucket, **kwargs
+                    )
+                else:
+                    assert len(data_dir) == len(dataset), (
+                        "Number of datasets and their directories must match"
+                    )
+                    datasets = []
+                    for i, _ in enumerate(data_dir):
+                        datasets.extend(
+                            self.load_bids_dataset(
+                                dataset[i],
+                                data_dir[i],
+                                description_fields,
+                                s3_bucket,
+                                **kwargs,
+                            )
+                        )
             else:
-                assert len(data_dir) == len(dataset), (
-                    "Number of datasets and their directories must match"
+                raise ValueError(
+                    "Exactly one of 'query' or 'data_dir' must be provided."
                 )
-                datasets = []
-                for i, _ in enumerate(data_dir):
-                    datasets.extend(
-                        self.load_bids_dataset(
-                            dataset[i], data_dir[i], description_fields, s3_bucket
-                        )
-                    )
+        finally:
+            # If we created the client, close it now that construction is done.
+            if _owns_client:
+                try:
+                    self.eeg_dash.close()
+                except Exception:
+                    # Don't let close errors break construction
+                    pass
 
         self.filesystem = S3FileSystem(
             anon=True, client_kwargs={"region_name": "us-east-2"}
         )
 
+        self.eeg_dash.close()
+
         super().__init__(datasets)
 
     def find_key_in_nested_dict(self, data: Any, target_key: str) -> Any:
@@ -628,27 +651,23 @@ class EEGDashDataset(BaseConcatDataset):
             A list of EEGDashBaseDataset objects that match the query.
 
         """
-        eeg_dash_instance = EEGDash()
-        try:
-            datasets = []
-            for record in eeg_dash_instance.find(query):
-                description = {}
-                for field in description_fields:
-                    value = self.find_key_in_nested_dict(record, field)
-                    if value is not None:
-                        description[field] = value
-                datasets.append(
-                    EEGDashBaseDataset(
-                        record,
-                        self.cache_dir,
-                        self.s3_bucket,
-                        description=description,
-                        **kwargs,
-                    )
+        datasets: list[EEGDashBaseDataset] = []
+        for record in self.eeg_dash.find(query):
+            description = {}
+            for field in description_fields:
+                value = self.find_key_in_nested_dict(record, field)
+                if value is not None:
+                    description[field] = value
+            datasets.append(
+                EEGDashBaseDataset(
+                    record,
+                    self.cache_dir,
+                    self.s3_bucket,
+                    description=description,
+                    **kwargs,
                 )
-            return datasets
-        finally:
-            eeg_dash_instance.close()
+            )
+        return datasets
 
     def load_bids_dataset(
         self,
@@ -676,36 +695,28 @@ class EEGDashDataset(BaseConcatDataset):
             data_dir=data_dir,
             dataset=dataset,
         )
-        eeg_dash_instance = EEGDash()
-        try:
-            datasets = Parallel(n_jobs=-1, prefer="threads", verbose=1)(
-                delayed(self.get_base_dataset_from_bids_file)(
-                    bids_dataset=bids_dataset,
-                    bids_file=bids_file,
-                    eeg_dash_instance=eeg_dash_instance,
-                    s3_bucket=s3_bucket,
-                    description_fields=description_fields,
-                )
-                for bids_file in bids_dataset.get_files()
+        datasets = Parallel(n_jobs=-1, prefer="threads", verbose=1)(
+            delayed(self.get_base_dataset_from_bids_file)(
+                bids_dataset=bids_dataset,
+                bids_file=bids_file,
+                s3_bucket=s3_bucket,
+                description_fields=description_fields,
+                **kwargs,
             )
-            return datasets
-        finally:
-            eeg_dash_instance.close()
+            for bids_file in bids_dataset.get_files()
+        )
+        return datasets
 
     def get_base_dataset_from_bids_file(
         self,
-        bids_dataset: EEGBIDSDataset,
+        bids_dataset: "EEGBIDSDataset",
         bids_file: str,
-        eeg_dash_instance: EEGDash,
         s3_bucket: str | None,
         description_fields: list[str],
-    ) -> EEGDashBaseDataset:
-        """Instantiate a single EEGDashBaseDataset given a local BIDS file. Note
-        this does not actually load the data from disk, but will access the metadata.
-        """
-        record = eeg_dash_instance.load_eeg_attrs_from_bids_file(
-            bids_dataset, bids_file
-        )
+        **kwargs,
+    ) -> "EEGDashBaseDataset":
+        """Instantiate a single EEGDashBaseDataset given a local BIDS file (metadata only)."""
+        record = self.eeg_dash.load_eeg_attrs_from_bids_file(bids_dataset, bids_file)
         description = {}
         for field in description_fields:
             value = self.find_key_in_nested_dict(record, field)
@@ -716,4 +727,5 @@ class EEGDashDataset(BaseConcatDataset):
             self.cache_dir,
             s3_bucket,
             description=description,
+            **kwargs,
         )

{eegdash-0.3.2.dev54 → eegdash-0.3.3}/eegdash/data_utils.py

@@ -10,6 +10,7 @@ import numpy as np
 import pandas as pd
 import s3fs
 from bids import BIDSLayout
+from fsspec.callbacks import TqdmCallback
 from joblib import Parallel, delayed
 from mne._fiff.utils import _read_segments_file
 from mne.io import BaseRaw
@@ -98,8 +99,27 @@ class EEGDashBaseDataset(BaseDataset):
             self.s3file = re.sub(r"(^|/)ds\d{6}/", r"\1", self.s3file, count=1)
 
         self.filecache.parent.mkdir(parents=True, exist_ok=True)
+        info = filesystem.info(self.s3file)
+        size = info.get("size") or info.get("Size")
+
+        callback = TqdmCallback(
+            size=size,
+            tqdm_kwargs=dict(
+                desc=f"Downloading {Path(self.s3file).name}",
+                unit="B",
+                unit_scale=True,
+                unit_divisor=1024,
+                dynamic_ncols=True,
+                leave=True,
+                mininterval=0.2,
+                smoothing=0.1,
+                miniters=1,
+                bar_format="{desc}: {percentage:3.0f}%|{bar}| {n_fmt}/{total_fmt} "
+                "[{elapsed}<{remaining}, {rate_fmt}]",
+            ),
+        )
+        filesystem.get(self.s3file, self.filecache, callback=callback)
 
-        filesystem.download(self.s3file, self.filecache)
         self.filenames = [self.filecache]
 
     def _download_dependencies(self) -> None:
@@ -119,7 +139,26 @@ class EEGDashBaseDataset(BaseDataset):
             # in the case of the competition.
             if not filepath.exists():
                 filepath.parent.mkdir(parents=True, exist_ok=True)
-                filesystem.download(s3path, filepath)
+                info = filesystem.info(s3path)
+                size = info.get("size") or info.get("Size")
+
+                callback = TqdmCallback(
+                    size=size,
+                    tqdm_kwargs=dict(
+                        desc=f"Downloading {Path(s3path).name}",
+                        unit="B",
+                        unit_scale=True,
+                        unit_divisor=1024,
+                        dynamic_ncols=True,
+                        leave=True,
+                        mininterval=0.2,
+                        smoothing=0.1,
+                        miniters=1,
+                        bar_format="{desc}: {percentage:3.0f}%|{bar}| {n_fmt}/{total_fmt} "
+                        "[{elapsed}<{remaining}, {rate_fmt}]",
+                    ),
+                )
+                filesystem.get(s3path, filepath, callback=callback)
 
     def get_raw_bids_args(self) -> dict[str, Any]:
         """Helper to restrict the metadata record to the fields needed to locate a BIDS

{eegdash-0.3.2.dev54 → eegdash-0.3.3}/eegdash/dataset.py

@@ -1,4 +1,7 @@
+from pathlib import Path
+
 from .api import EEGDashDataset
+from .registry import register_openneuro_datasets
 
 RELEASE_TO_OPENNEURO_DATASET_MAP = {
     "R11": "ds005516",
@@ -67,3 +70,13 @@ class EEGChallengeDataset(EEGDashDataset):
             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())

eegdash-0.3.3/eegdash/registry.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import csv
+from pathlib import Path
+from typing import Any, Dict
+
+
+def register_openneuro_datasets(
+    summary_file: str | Path,
+    *,
+    base_class=None,
+    namespace: Dict[str, Any] | None = None,
+) -> Dict[str, type]:
+    """Dynamically create dataset classes from a summary file.
+
+    Parameters
+    ----------
+    summary_file : str | Path
+        Path to a CSV file where each line starts with the dataset identifier.
+    base_class : type | None
+        Base class for the generated datasets. If ``None``, defaults to
+        :class:`eegdash.api.EEGDashDataset`.
+    namespace : dict | None
+        Mapping where the new classes will be registered. Defaults to the
+        module's global namespace.
+
+    Returns
+    -------
+    dict
+        Mapping from class names to the generated classes.
+
+    """
+    if base_class is None:
+        from .api import EEGDashDataset as base_class  # lazy import
+
+    summary_path = Path(summary_file)
+    namespace = namespace if namespace is not None else globals()
+    registered: Dict[str, type] = {}
+
+    with summary_path.open() as f:
+        reader = csv.reader(f)
+        for row in reader:
+            if not row:
+                continue
+            dataset_id = row[0].strip()
+            if not dataset_id or dataset_id.startswith("#"):
+                continue
+            class_name = dataset_id.upper()
+
+            def __init__(
+                self,
+                cache_dir: str,
+                query: dict | None = None,
+                s3_bucket: str | None = None,
+                **kwargs,
+            ):
+                q = {"dataset": self._dataset}
+                if query:
+                    q.update(query)
+                super().__init__(
+                    query=q, cache_dir=cache_dir, s3_bucket=s3_bucket, **kwargs
+                )
+
+            cls = type(
+                class_name,
+                (base_class,),
+                {"_dataset": dataset_id, "__init__": __init__},
+            )
+            namespace[class_name] = cls
+            registered[class_name] = cls
+
+    return registered

{eegdash-0.3.2.dev54 → eegdash-0.3.3}/eegdash.egg-info/PKG-INFO

@@ -1,35 +1,11 @@
 Metadata-Version: 2.4
 Name: eegdash
-Version: 0.3.2.dev54
+Version: 0.3.3
 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: GNU General Public License
-        
-        Copyright (C) 2024-2025
-        
-        Young Truong, UCSD, dt.young112@gmail.com
-        Arnaud Delorme, UCSD, adelorme@ucsd.edu
-        Aviv Dotan, BGU, avivdot@bgu.post.ac.il
-        Oren Shriki, BGU, shrikio@bgu.ac.il
-        Bruno Aristimunha, b.aristimunha@gmail.com
-        
-        This program is free software; you can redistribute it and/or modify
-        it under the terms of the GNU General Public License as published by
-        the Free Software Foundation; either version 2 of the License, or
-        (at your option) any later version.
-        
-        This program is distributed in the hope that it will be useful,
-        but WITHOUT ANY WARRANTY; without even the implied warranty of
-        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-        GNU General Public License for more details.
-        
-        You should have received a copy of the GNU General Public License
-        along with this program; if not, write to the Free Software
-        Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1.07  USA
-        
+License-Expression: GPL-3.0-only
 Project-URL: Homepage, https://github.com/sccn/EEG-Dash-Data
 Project-URL: Issues, https://github.com/sccn/EEG-Dash-Data/issues
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Intended Audience :: Science/Research
 Classifier: Intended Audience :: Developers
@@ -60,6 +36,8 @@ Requires-Dist: s3fs
 Requires-Dist: scipy
 Requires-Dist: tqdm
 Requires-Dist: xarray
+Requires-Dist: h5io>=0.2.4
+Requires-Dist: pymatreader
 Provides-Extra: tests
 Requires-Dist: pytest; extra == "tests"
 Requires-Dist: pytest-cov; extra == "tests"

{eegdash-0.3.2.dev54 → eegdash-0.3.3}/eegdash.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ eegdash/data_utils.py
 eegdash/dataset.py
 eegdash/mongodb.py
 eegdash/preprocessing.py
+eegdash/registry.py
 eegdash/utils.py
 eegdash.egg-info/PKG-INFO
 eegdash.egg-info/SOURCES.txt
@@ -31,6 +32,8 @@ eegdash/features/feature_bank/spectral.py
 eegdash/features/feature_bank/utils.py
 tests/test_correctness.py
 tests/test_dataset.py
+tests/test_dataset_registration.py
 tests/test_eegdash.py
+tests/test_functional.py
 tests/test_init.py
 tests/test_mongo_connection.py

{eegdash-0.3.2.dev54 → eegdash-0.3.3}/eegdash.egg-info/requires.txt

@@ -10,6 +10,8 @@ s3fs
 scipy
 tqdm
 xarray
+h5io>=0.2.4
+pymatreader
 
 [all]
 pre-commit

{eegdash-0.3.2.dev54 → eegdash-0.3.3}/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["setuptools>=64", "wheel"]
+requires = ["setuptools>=77", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [project]
@@ -14,11 +14,10 @@ authors = [
 ]
 description     = "EEG data for machine learning"
 readme          = "README.md"
-license         = { file = "LICENSE" }
+license         = "GPL-3.0-only"
 requires-python = ">=3.10"
 
 classifiers = [
-    "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
     "Intended Audience :: Science/Research",
     "Intended Audience :: Developers",
@@ -48,6 +47,8 @@ dependencies = [
   "scipy",
   "tqdm",
   "xarray",
+  "h5io >= 0.2.4",
+  "pymatreader",
 ]
 
 [project.urls]

{eegdash-0.3.2.dev54 → eegdash-0.3.3}/tests/test_dataset.py

@@ -12,8 +12,6 @@ FILES_PER_RELEASE = [1342, 1405, 1812, 3342, 3326, 1227, 3100, 2320, 2885, 2516,
 RELEASE_FILES = list(zip(RELEASES, FILES_PER_RELEASE))
 
 CACHE_DIR = (Path.home() / "mne_data" / "eeg_challenge_cache").resolve()
-print()
-print(CACHE_DIR)
 CACHE_DIR.mkdir(parents=True, exist_ok=True)
 
 
@@ -98,3 +96,15 @@ def test_consuming_data_r5():
     )
     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):
+    dataset_obj = EEGChallengeDataset(
+        release="R5",
+        query=dict(task="RestingState", subject="NDARAC350XUM"),
+        cache_dir=CACHE_DIR,
+        eeg_dash_instance=eeg_dash_instance,
+    )
+    raw = dataset_obj.datasets[0].raw
+    assert raw is not None

eegdash-0.3.3/tests/test_dataset_registration.py

@@ -0,0 +1,33 @@
+import importlib.util
+from pathlib import Path
+
+
+class DummyBase:
+    pass
+
+
+def test_register_openneuro_datasets(tmp_path: Path):
+    module_path = Path(__file__).resolve().parents[1] / "eegdash" / "registry.py"
+    spec = importlib.util.spec_from_file_location("registry", module_path)
+    registry = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(registry)
+
+    summary = tmp_path / "dataset_summary.csv"
+    summary.write_text(
+        "\n".join(
+            [
+                "ds002718,18,18,1,74,250,14.844",
+                "ds000001,1,1,1,1,1,1",
+            ]
+        )
+    )
+    namespace = {}
+    registered = registry.register_openneuro_datasets(
+        summary, namespace=namespace, base_class=DummyBase
+    )
+
+    assert set(registered) == {"DS002718", "DS000001"}
+    ds_class = registered["DS002718"]
+    assert ds_class is namespace["DS002718"]
+    assert issubclass(ds_class, DummyBase)
+    assert ds_class._dataset == "ds002718"

eegdash-0.3.3/tests/test_functional.py

@@ -0,0 +1,28 @@
+import shutil
+from pathlib import Path
+
+from eegdash.dataset import EEGDashDataset
+
+
+def test_progress_bar_output(capsys, tmp_path):
+    temporary = (Path.home() / "mne_data" / "temp").resolve()
+
+    if temporary.exists():
+        shutil.rmtree(temporary)
+
+    temporary.mkdir(parents=True, exist_ok=True)
+
+    eegdash_dataset = EEGDashDataset(
+        query={
+            "dataset": "ds005514",
+            "task": "RestingState",
+            "subject": "NDARDB033FW5",
+        },
+        cache_dir=temporary,
+    )
+    _ = eegdash_dataset.datasets[0].raw
+
+    out = capsys.readouterr()
+    # tqdm uses carriage returns; just assert a stable fragment:
+    assert "Downloading" in out.err
+    assert out.err  # non-empty