eegdash 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

eegdash/preprocessing.py

@@ -0,0 +1,65 @@
+import logging
+
+import mne
+import numpy as np
+
+from braindecode.preprocessing import (
+    Preprocessor,
+)
+
+logger = logging.getLogger("eegdash")
+
+
+class hbn_ec_ec_reannotation(Preprocessor):
+    """Preprocessor to reannotate the raw data for eyes open and eyes closed events.
+
+    This processor is designed for HBN datasets.
+
+    """
+
+    def __init__(self):
+        super().__init__(fn=self.transform, apply_on_array=False)
+
+    def transform(self, raw):
+        """Reannotate the raw data to create new events for eyes open and eyes closed
+
+        This function modifies the raw MNE object by creating new events based on
+        the existing annotations for "instructed_toCloseEyes" and "instructed_toOpenEyes".
+        It generates new events every 2 seconds within specified time ranges after
+        the original events, and replaces the existing annotations with these new events.
+
+        Parameters
+        ----------
+        raw : mne.io.Raw
+            The raw MNE object containing EEG data and annotations.
+
+        """
+        events, event_id = mne.events_from_annotations(raw)
+
+        logger.info("Original events found with ids: %s", event_id)
+
+        # Create new events array for 2-second segments
+        new_events = []
+        sfreq = raw.info["sfreq"]
+        for event in events[events[:, 2] == event_id["instructed_toCloseEyes"]]:
+            # For each original event, create events every 2 seconds from 15s to 29s after
+            start_times = event[0] + np.arange(15, 29, 2) * sfreq
+            new_events.extend([[int(t), 0, 1] for t in start_times])
+
+        for event in events[events[:, 2] == event_id["instructed_toOpenEyes"]]:
+            # For each original event, create events every 2 seconds from 5s to 19s after
+            start_times = event[0] + np.arange(5, 19, 2) * sfreq
+            new_events.extend([[int(t), 0, 2] for t in start_times])
+
+        # replace events in raw
+        new_events = np.array(new_events)
+
+        annot_from_events = mne.annotations_from_events(
+            events=new_events,
+            event_desc={1: "eyes_closed", 2: "eyes_open"},
+            sfreq=raw.info["sfreq"],
+        )
+
+        raw.set_annotations(annot_from_events)
+
+        return raw

eegdash/utils.py

@@ -0,0 +1,11 @@
+def __init__mongo_client():
+    from mne.utils import get_config, set_config
+
+    if get_config("EEGDASH_DB_URI") is None:
+        # Set the default MongoDB URI for EEGDash
+        # This is a placeholder and should be replaced with your actual MongoDB URI
+
+        set_config(
+            "EEGDASH_DB_URI",
+            "mongodb+srv://eegdash-user:mdzoMjQcHWTVnKDq@cluster0.vz35p.mongodb.net/?retryWrites=true&w=majority&appName=Cluster0",
+        )

{eegdash-0.1.0.dist-info → eegdash-0.2.0.dist-info}/METADATA

@@ -1,14 +1,15 @@
 Metadata-Version: 2.4
 Name: eegdash
-Version: 0.1.0
+Version: 0.2.0
 Summary: EEG data for machine learning
-Author-email: Young Truong <dt.young112@gmail.com>, Arnaud Delorme <adelorme@gmail.com>
+Author-email: Young Truong <dt.young112@gmail.com>, Arnaud Delorme <adelorme@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
+        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
@@ -26,14 +27,27 @@ License: GNU General Public License
         
 Project-URL: Homepage, https://github.com/sccn/EEG-Dash-Data
 Project-URL: Issues, https://github.com/sccn/EEG-Dash-Data/issues
-Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development
+Classifier: Topic :: Scientific/Engineering
+Classifier: Development Status :: 3 - Alpha
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: braindecode
-Requires-Dist: mne_bids
+Requires-Dist: braindecode>=1.0
+Requires-Dist: mne_bids>=0.16.0
 Requires-Dist: numba
 Requires-Dist: numpy
 Requires-Dist: pandas
@@ -44,13 +58,36 @@ Requires-Dist: s3fs
 Requires-Dist: scipy
 Requires-Dist: tqdm
 Requires-Dist: xarray
-Requires-Dist: pre-commit
+Provides-Extra: tests
+Requires-Dist: pytest; extra == "tests"
+Requires-Dist: pytest-cov; extra == "tests"
+Requires-Dist: codecov; extra == "tests"
+Requires-Dist: pytest_cases; extra == "tests"
+Provides-Extra: dev
+Requires-Dist: pre-commit; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinx_gallery; extra == "docs"
+Requires-Dist: sphinx_rtd_theme; extra == "docs"
+Requires-Dist: numpydoc; extra == "docs"
+Provides-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: pre-commit; extra == "all"
+Requires-Dist: sphinx; extra == "all"
+Requires-Dist: sphinx_gallery; extra == "all"
+Requires-Dist: sphinx_rtd_theme; extra == "all"
+Requires-Dist: numpydoc; extra == "all"
 Dynamic: license-file
 
 # EEG-Dash
+
 To leverage recent and ongoing advancements in large-scale computational methods and to ensure the preservation of scientific data generated from publicly funded research, the EEG-DaSh data archive will create a data-sharing resource for MEEG (EEG, MEG) data contributed by collaborators for machine learning (ML) and deep learning (DL) applications. 
 
 ## Data source
+
 The data in EEG-DaSh originates from a collaboration involving 25 laboratories, encompassing 27,053 participants. This extensive collection includes MEEG data, which is a combination of EEG and MEG signals. The data is sourced from various studies conducted by these labs, involving both healthy subjects and clinical populations with conditions such as ADHD, depression, schizophrenia, dementia, autism, and psychosis. Additionally, data spans different mental states like sleep, meditation, and cognitive tasks. In addition, EEG-DaSh will incorporate a subset of the data converted from NEMAR, which includes 330 MEEG BIDS-formatted datasets, further expanding the archive with well-curated, standardized neuroelectromagnetic data.
 
 ## Featured data
@@ -70,9 +107,11 @@ The following HBN datasets are currently featured on EEGDash. Documentation abou
 A total of [246 other datasets](datasets.md) are also available through EEGDash. 
 
 ## Data format
+
 EEGDash queries return a **Pytorch Dataset** formatted to facilitate machine learning (ML) and deep learning (DL) applications. PyTorch Datasets are the best format for EEGDash queries because they provide an efficient, scalable, and flexible structure for machine learning (ML) and deep learning (DL) applications. They allow seamless integration with PyTorch’s DataLoader, enabling efficient batching, shuffling, and parallel data loading, which is essential for training deep learning models on large EEG datasets.
 
 ## Data preprocessing
+
 EEGDash datasets are processed using the popular [BrainDecode](https://braindecode.org/stable/index.html) library. In fact, EEGDash datasets are BrainDecode datasets, which are themselves PyTorch datasets. This means that any preprocessing possible on BrainDecode datasets is also possible on EEGDash datasets. Refer to [BrainDecode](https://braindecode.org/stable/index.html) tutorials for guidance on preprocessing EEG data.
 
 ## EEG-Dash usage
@@ -125,3 +164,7 @@ EEG-DaSh is a collaborative initiative between the United States and Israel, sup
 
 
 
+python3 -m pip install --upgrade build
+python3 -m build
+python3 -m pip install --upgrade twine
+python3 -m twine upload --repository eegdash dist/*

eegdash-0.2.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+eegdash/__init__.py,sha256=nMBZrB4bJs79rl9TZ_x-IVPNTHYJS6V55Pus9fErB5E,232
+eegdash/api.py,sha256=1mbufz6qgujrY_9V2GWUP4Eqel_q4ns9XVrmbGcSJG0,25776
+eegdash/data_config.py,sha256=OS6ERO-jHrnEOfMJUehY7ieABdsRw_qWzOKJ4pzSfqw,1323
+eegdash/data_utils.py,sha256=mR0TtERYIefakGQ98jwAeeRVKSNDU9eBlUoH1AY9tnc,23663
+eegdash/dataset.py,sha256=qXcE4JxxYj89VQ84sKmq7kGcunZqt1pp5wz7a62j_OQ,2460
+eegdash/preprocessing.py,sha256=wvqAO8UgDoQQz7xjVykrl4V8AawS4tpKR4Vrr_9BovY,2230
+eegdash/utils.py,sha256=ZxVW4ll5MaSZ_ht1L5p7YJxOtYi3b0547oa5W_jbH4A,450
+eegdash/features/__init__.py,sha256=484CLxpPifc8ZQfeM8jWZLvtVKljCxn3qqlUCaq-Yxk,1284
+eegdash/features/datasets.py,sha256=kU1DO70ArSIy-LF1hHD2NN4iT-kJrI0mVpSkyV_OSeI,18301
+eegdash/features/decorators.py,sha256=v0qaJz_dcX703p1fvFYbAIXmwK3d8naYGlq7fRVKn_w,1313
+eegdash/features/extractors.py,sha256=H7h6tP3dKoRcjDJpWWAo0ppmokCq5QlhqMcehYwYV9s,6845
+eegdash/features/inspect.py,sha256=PmbWhx5H_WqpnorUpWONUSkUtaIHkZblRa_Xyk7Szyc,1569
+eegdash/features/serialization.py,sha256=pNsTz0EeRPPYE-A61XK7UoMShI9YBEHQqC5STbzUU6A,2861
+eegdash/features/utils.py,sha256=eM6DdyOpdVfNh7dSPykJ0WaTDtaGvkCQWAmW0G8v60Y,3784
+eegdash/features/feature_bank/__init__.py,sha256=BKrM3aaggXrfey1yEjEBYaxOV5e3UK-o8oGeB30epOg,149
+eegdash/features/feature_bank/complexity.py,sha256=Ds1GAXZ0LGM32xB4EZC2jbMljUBv0yicf2SkuyLvN5I,3183
+eegdash/features/feature_bank/connectivity.py,sha256=bQ6KlxWm5GNpCS9ypLqBUr2L171Yq7wpBQT2tRQKTZ4,2159
+eegdash/features/feature_bank/csp.py,sha256=YOzieLnOcqjvfrcjvg8R3S4SWuC1BqK5J5WXVNCCTc0,3304
+eegdash/features/feature_bank/dimensionality.py,sha256=j_Ds71Y1AbV2uLFQj8EuXQ4kzofLBlQtPV5snMkF7i4,3965
+eegdash/features/feature_bank/signal.py,sha256=3Tb8z9gX7iZipxQJ9DSyy30JfdmW58kgvimSyZX74p8,3404
+eegdash/features/feature_bank/spectral.py,sha256=bNB7skusePs1gX7NOU6yRlw_Gr4UOCkO_ylkCgybzug,3319
+eegdash/features/feature_bank/utils.py,sha256=DGh-Q7-XFIittP7iBBxvsJaZrlVvuY5mw-G7q6C-PCI,1237
+eegdash-0.2.0.dist-info/licenses/LICENSE,sha256=KykUD4H3kw3HLz5bZ0kxMWwZotnk8rhkfCCerGyX2sk,855
+eegdash-0.2.0.dist-info/METADATA,sha256=GhxMc7p2HvTZo9lZFjBX1tJ70VeMlMnaYBhvpqw0iG8,10220
+eegdash-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+eegdash-0.2.0.dist-info/top_level.txt,sha256=zavO69HQ6MyZM0aQMR2zUS6TAFc7bnN5GEpDpOpFZzU,8
+eegdash-0.2.0.dist-info/RECORD,,

{eegdash-0.1.0.dist-info → eegdash-0.2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.8.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{eegdash-0.1.0.dist-info → eegdash-0.2.0.dist-info}/licenses/LICENSE

@@ -4,6 +4,7 @@ Copyright (C) 2024-2025
 
 Young Truong, UCSD, dt.young112@gmail.com
 Arnaud Delorme, UCSD, adelorme@ucsd.edu
+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

eegdash/main.py

@@ -1,416 +0,0 @@
-import json
-import os
-import tempfile
-from collections import defaultdict
-from pathlib import Path
-
-import mne
-import numpy as np
-import pymongo
-import s3fs
-import xarray as xr
-from dotenv import load_dotenv
-from joblib import Parallel, delayed
-from pymongo import DeleteOne, InsertOne, MongoClient, UpdateOne
-
-from braindecode.datasets import BaseConcatDataset, BaseDataset
-
-from .data_config import config as data_config
-from .data_utils import EEGBIDSDataset, EEGDashBaseDataset, EEGDashBaseRaw
-
-
-class EEGDash:
-    AWS_BUCKET = "s3://openneuro.org"
-
-    def __init__(self, is_public=True):
-        # Load config file
-        # config_path = Path(__file__).parent / 'config.json'
-        # with open(config_path, 'r') as f:
-        #     self.config = json.load(f)
-
-        self.config = data_config
-        if is_public:
-            DB_CONNECTION_STRING = "mongodb+srv://eegdash-user:mdzoMjQcHWTVnKDq@cluster0.vz35p.mongodb.net/?retryWrites=true&w=majority&appName=Cluster0"
-        else:
-            load_dotenv()
-            DB_CONNECTION_STRING = os.getenv("DB_CONNECTION_STRING")
-
-        self.__client = pymongo.MongoClient(DB_CONNECTION_STRING)
-        self.__db = self.__client["eegdash"]
-        self.__collection = self.__db["records"]
-
-        self.is_public = is_public
-        self.filesystem = s3fs.S3FileSystem(
-            anon=True, client_kwargs={"region_name": "us-east-2"}
-        )
-
-    def find(self, *args):
-        results = self.__collection.find(*args)
-
-        # convert to list using get_item on each element
-        return [result for result in results]
-
-    def exist(self, query: dict):
-        accepted_query_fields = ["data_name", "dataset"]
-        assert all(field in accepted_query_fields for field in query.keys())
-        sessions = self.find(query)
-        return len(sessions) > 0
-
-    def _validate_input(self, record: dict):
-        input_types = {
-            "data_name": str,
-            "dataset": str,
-            "bidspath": str,
-            "subject": str,
-            "task": str,
-            "session": str,
-            "run": str,
-            "sampling_frequency": float,
-            "modality": str,
-            "nchans": int,
-            "ntimes": int,
-            "channel_types": list,
-            "channel_names": list,
-        }
-        if "data_name" not in record:
-            raise ValueError("Missing key: data_name")
-        # check if args are in the keys and has correct type
-        for key, value in record.items():
-            if key not in input_types:
-                raise ValueError(f"Invalid input: {key}")
-            if not isinstance(value, input_types[key]):
-                raise ValueError(f"Invalid input: {key}")
-
-        return record
-
-    def load_eeg_data_from_s3(self, s3path):
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".set") as tmp:
-            with self.filesystem.open(s3path) as s3_file:
-                tmp.write(s3_file.read())
-            tmp_path = tmp.name
-            eeg_data = self.load_eeg_data_from_bids_file(tmp_path)
-            os.unlink(tmp_path)
-            return eeg_data
-
-    def load_eeg_data_from_bids_file(self, bids_file, eeg_attrs=None):
-        """
-        bids_file must be a file of the bids_dataset
-        """
-        EEG = mne.io.read_raw_eeglab(bids_file)
-        eeg_data = EEG.get_data()
-
-        fs = EEG.info["sfreq"]
-        max_time = eeg_data.shape[1] / fs
-        time_steps = np.linspace(0, max_time, eeg_data.shape[1]).squeeze()  # in seconds
-
-        channel_names = EEG.ch_names
-
-        eeg_xarray = xr.DataArray(
-            data=eeg_data,
-            dims=["channel", "time"],
-            coords={"time": time_steps, "channel": channel_names},
-            # attrs=attrs
-        )
-        return eeg_xarray
-
-    def get_raw_extensions(self, bids_file, bids_dataset: EEGBIDSDataset):
-        bids_file = Path(bids_file)
-        extensions = {
-            ".set": [".set", ".fdt"],  # eeglab
-            ".edf": [".edf"],  # european
-            ".vhdr": [".eeg", ".vhdr", ".vmrk", ".dat", ".raw"],  # brainvision
-            ".bdf": [".bdf"],  # biosemi
-        }
-        return [
-            str(bids_dataset.get_relative_bidspath(bids_file.with_suffix(suffix)))
-            for suffix in extensions[bids_file.suffix]
-            if bids_file.with_suffix(suffix).exists()
-        ]
-
-    def load_eeg_attrs_from_bids_file(self, bids_dataset: EEGBIDSDataset, bids_file):
-        """
-        bids_file must be a file of the bids_dataset
-        """
-        if bids_file not in bids_dataset.files:
-            raise ValueError(f"{bids_file} not in {bids_dataset.dataset}")
-
-        # Initialize attrs with None values for all expected fields
-        attrs = {field: None for field in self.config["attributes"].keys()}
-
-        f = os.path.basename(bids_file)
-        dsnumber = bids_dataset.dataset
-        # extract openneuro path by finding the first occurrence of the dataset name in the filename and remove the path before that
-        openneuro_path = dsnumber + bids_file.split(dsnumber)[1]
-
-        # Update with actual values where available
-        try:
-            participants_tsv = bids_dataset.subject_participant_tsv(bids_file)
-        except Exception as e:
-            print(f"Error getting participants_tsv: {str(e)}")
-            participants_tsv = None
-
-        try:
-            eeg_json = bids_dataset.eeg_json(bids_file)
-        except Exception as e:
-            print(f"Error getting eeg_json: {str(e)}")
-            eeg_json = None
-
-        bids_dependencies_files = self.config["bids_dependencies_files"]
-        bidsdependencies = []
-        for extension in bids_dependencies_files:
-            try:
-                dep_path = bids_dataset.get_bids_metadata_files(bids_file, extension)
-                dep_path = [
-                    str(bids_dataset.get_relative_bidspath(dep)) for dep in dep_path
-                ]
-                bidsdependencies.extend(dep_path)
-            except Exception as e:
-                pass
-
-        bidsdependencies.extend(self.get_raw_extensions(bids_file, bids_dataset))
-
-        # Define field extraction functions with error handling
-        field_extractors = {
-            "data_name": lambda: f"{bids_dataset.dataset}_{f}",
-            "dataset": lambda: bids_dataset.dataset,
-            "bidspath": lambda: openneuro_path,
-            "subject": lambda: bids_dataset.get_bids_file_attribute(
-                "subject", bids_file
-            ),
-            "task": lambda: bids_dataset.get_bids_file_attribute("task", bids_file),
-            "session": lambda: bids_dataset.get_bids_file_attribute(
-                "session", bids_file
-            ),
-            "run": lambda: bids_dataset.get_bids_file_attribute("run", bids_file),
-            "modality": lambda: bids_dataset.get_bids_file_attribute(
-                "modality", bids_file
-            ),
-            "sampling_frequency": lambda: bids_dataset.get_bids_file_attribute(
-                "sfreq", bids_file
-            ),
-            "nchans": lambda: bids_dataset.get_bids_file_attribute("nchans", bids_file),
-            "ntimes": lambda: bids_dataset.get_bids_file_attribute("ntimes", bids_file),
-            "participant_tsv": lambda: participants_tsv,
-            "eeg_json": lambda: eeg_json,
-            "bidsdependencies": lambda: bidsdependencies,
-        }
-
-        # Dynamically populate attrs with error handling
-        for field, extractor in field_extractors.items():
-            try:
-                attrs[field] = extractor()
-            except Exception as e:
-                print(f"Error extracting {field}: {str(e)}")
-                attrs[field] = None
-
-        return attrs
-
-    def add_bids_dataset(self, dataset, data_dir, overwrite=True):
-        """
-        Create new records for the dataset in the MongoDB database if not found
-        """
-        if self.is_public:
-            raise ValueError("This operation is not allowed for public users")
-
-        if not overwrite and self.exist({"dataset": dataset}):
-            print(f"Dataset {dataset} already exists in the database")
-            return
-        try:
-            bids_dataset = EEGBIDSDataset(
-                data_dir=data_dir,
-                dataset=dataset,
-            )
-        except Exception as e:
-            print(f"Error creating bids dataset {dataset}: {str(e)}")
-            raise e
-        requests = []
-        for bids_file in bids_dataset.get_files():
-            try:
-                data_id = f"{dataset}_{os.path.basename(bids_file)}"
-
-                if self.exist({"data_name": data_id}):
-                    if overwrite:
-                        eeg_attrs = self.load_eeg_attrs_from_bids_file(
-                            bids_dataset, bids_file
-                        )
-                        requests.append(self.update_request(eeg_attrs))
-                else:
-                    eeg_attrs = self.load_eeg_attrs_from_bids_file(
-                        bids_dataset, bids_file
-                    )
-                    requests.append(self.add_request(eeg_attrs))
-            except:
-                print("error adding record", bids_file)
-
-        print("Number of database requests", len(requests))
-
-        if requests:
-            result = self.__collection.bulk_write(requests, ordered=False)
-            print(f"Inserted: {result.inserted_count}")
-            print(f"Modified: {result.modified_count}")
-            print(f"Deleted: {result.deleted_count}")
-            print(f"Upserted: {result.upserted_count}")
-            print(f"Errors: {result.bulk_api_result.get('writeErrors', [])}")
-
-    def get(self, query: dict):
-        """
-        query: {
-            'dataset': 'dsxxxx',
-
-        }"""
-        sessions = self.find(query)
-        results = []
-        if sessions:
-            print(f"Found {len(sessions)} records")
-            results = Parallel(
-                n_jobs=-1 if len(sessions) > 1 else 1, prefer="threads", verbose=1
-            )(
-                delayed(self.load_eeg_data_from_s3)(self.get_s3path(session))
-                for session in sessions
-            )
-        return results
-
-    def add_request(self, record: dict):
-        return InsertOne(record)
-
-    def add(self, record: dict):
-        try:
-            # input_record = self._validate_input(record)
-            self.__collection.insert_one(record)
-        # silent failing
-        except ValueError as e:
-            print(f"Failed to validate record: {record['data_name']}")
-            print(e)
-        except:
-            print(f"Error adding record: {record['data_name']}")
-
-    def update_request(self, record: dict):
-        return UpdateOne({"data_name": record["data_name"]}, {"$set": record})
-
-    def update(self, record: dict):
-        try:
-            self.__collection.update_one(
-                {"data_name": record["data_name"]}, {"$set": record}
-            )
-        except:  # silent failure
-            print(f"Error updating record {record['data_name']}")
-
-    def remove_field(self, record, field):
-        self.__collection.update_one(
-            {"data_name": record["data_name"]}, {"$unset": {field: 1}}
-        )
-
-    def remove_field_from_db(self, field):
-        self.__collection.update_many({}, {"$unset": {field: 1}})
-
-    @property
-    def collection(self):
-        return self.__collection
-
-
-class EEGDashDataset(BaseConcatDataset):
-    # CACHE_DIR = '.eegdash_cache'
-    def __init__(
-        self,
-        query: dict = None,
-        data_dir: str | list = None,
-        dataset: str | list = None,
-        description_fields: list[str] = [
-            "subject",
-            "session",
-            "run",
-            "task",
-            "age",
-            "gender",
-            "sex",
-        ],
-        cache_dir: str = ".eegdash_cache",
-        **kwargs,
-    ):
-        self.cache_dir = cache_dir
-        if query:
-            datasets = self.find_datasets(query, description_fields, **kwargs)
-        elif data_dir:
-            if type(data_dir) == str:
-                datasets = self.load_bids_dataset(dataset, data_dir, description_fields)
-            else:
-                assert len(data_dir) == len(dataset), (
-                    "Number of datasets and their directories must match"
-                )
-                datasets = []
-                for i in range(len(data_dir)):
-                    datasets.extend(
-                        self.load_bids_dataset(
-                            dataset[i], data_dir[i], description_fields
-                        )
-                    )
-        # convert to list using get_item on each element
-        super().__init__(datasets)
-
-    def find_key_in_nested_dict(self, data, target_key):
-        if isinstance(data, dict):
-            if target_key in data:
-                return data[target_key]
-            for value in data.values():
-                result = self.find_key_in_nested_dict(value, target_key)
-                if result is not None:
-                    return result
-        return None
-
-    def find_datasets(self, query: dict, description_fields: list[str], **kwargs):
-        eegdashObj = EEGDash()
-        datasets = []
-        for record in eegdashObj.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, description=description, **kwargs
-                )
-            )
-        return datasets
-
-    def load_bids_dataset(
-        self,
-        dataset,
-        data_dir,
-        description_fields: list[str],
-        raw_format="eeglab",
-        **kwargs,
-    ):
-        """ """
-
-        def get_base_dataset_from_bids_file(bids_dataset, bids_file):
-            record = eegdashObj.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)
-                if value is not None:
-                    description[field] = value
-            return EEGDashBaseDataset(
-                record, self.cache_dir, description=description, **kwargs
-            )
-
-        bids_dataset = EEGBIDSDataset(
-            data_dir=data_dir,
-            dataset=dataset,
-        )
-        eegdashObj = EEGDash()
-        datasets = Parallel(n_jobs=-1, prefer="threads", verbose=1)(
-            delayed(get_base_dataset_from_bids_file)(bids_dataset, bids_file)
-            for bids_file in bids_dataset.get_files()
-        )
-        return datasets
-
-
-def main():
-    eegdash = EEGDash()
-    record = eegdash.find({"dataset": "ds005511", "subject": "NDARUF236HM7"})
-    print(record)
-
-
-if __name__ == "__main__":
-    main()

eegdash-0.1.0.dist-info/RECORD

@@ -1,23 +0,0 @@
-eegdash/__init__.py,sha256=dyNvSv7ORVDYDz0P-XBNj_SApMlOqwt8LHQqfeuPKCg,105
-eegdash/data_config.py,sha256=sIwj7lnZ1hCjeFs-0CXeHn93btm9fX7mwgVTZVeVh-w,763
-eegdash/data_utils.py,sha256=LqAJygSpPpYEIerAnWHuHP0OMjd7jQtzXIodbvb0568,19436
-eegdash/main.py,sha256=CFI-Bro_oru5iRJdNQZ8IqeRPhrZKXj8wKoMdcrhFt8,14865
-eegdash/features/__init__.py,sha256=Ijhc-bLwysyF_HTmdJwbYoTHbxj2wxArs1xSUzhm7Hc,604
-eegdash/features/datasets.py,sha256=JB-VTfXTwfbxpgF9wq34gKK69YNCZPQwsnaKEXQisWk,17180
-eegdash/features/decorators.py,sha256=iVsbdQXGoLi-V6M9BgP6P8i_UzUtIAWQlf8Qq_LdRqY,1247
-eegdash/features/extractors.py,sha256=bITM4DXbW1Dq8Nm8hS3OrSGfRFV6-IwzkTzjiy_yg9k,6816
-eegdash/features/serialization.py,sha256=ceGcEvKCg4OsWyLpdAyJsvU1-6UXcvVx2q6nq58vt8Y,2873
-eegdash/features/utils.py,sha256=jjVNVLFSXFj3j7NWgEbUlt5faTrWKLLQY9ZYy0xLp_M,3782
-eegdash/features/feature_bank/__init__.py,sha256=BKrM3aaggXrfey1yEjEBYaxOV5e3UK-o8oGeB30epOg,149
-eegdash/features/feature_bank/complexity.py,sha256=WkLin-f1WTPUtcpkLDObY8nQYRsvpa08Xy9ly1k0hik,3017
-eegdash/features/feature_bank/connectivity.py,sha256=bQ6KlxWm5GNpCS9ypLqBUr2L171Yq7wpBQT2tRQKTZ4,2159
-eegdash/features/feature_bank/csp.py,sha256=O-kUijM47cOH7yfe7sYL9wT41w1dGaq6sOieh-h82pw,3300
-eegdash/features/feature_bank/dimensionality.py,sha256=e8rKpAT_xtZRsBDuVbznFx_daWdQj89Z3Zkt61Hs5qk,3734
-eegdash/features/feature_bank/signal.py,sha256=4jgIXRVS274puKfOnDNnqLoBP_yXRyP38iMnXRvobYo,2437
-eegdash/features/feature_bank/spectral.py,sha256=bNB7skusePs1gX7NOU6yRlw_Gr4UOCkO_ylkCgybzug,3319
-eegdash/features/feature_bank/utils.py,sha256=DGh-Q7-XFIittP7iBBxvsJaZrlVvuY5mw-G7q6C-PCI,1237
-eegdash-0.1.0.dist-info/licenses/LICENSE,sha256=Xafu48R-h_kyaNj2tuhfgdEv9_ovciktjUEgRRwMZ6w,812
-eegdash-0.1.0.dist-info/METADATA,sha256=RixWQ9dqP1IQzz_HCAZL2Sp-at190rx4ocpvy2DVaio,8551
-eegdash-0.1.0.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-eegdash-0.1.0.dist-info/top_level.txt,sha256=zavO69HQ6MyZM0aQMR2zUS6TAFc7bnN5GEpDpOpFZzU,8
-eegdash-0.1.0.dist-info/RECORD,,