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

eegdash/main.py

@@ -1,24 +1,28 @@
-import pymongo
-from dotenv import load_dotenv
-import os
-from pathlib import Path
-import s3fs
-from joblib import Parallel, delayed
 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 .data_utils import EEGBIDSDataset, EEGDashBaseRaw, EEGDashBaseDataset
+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 braindecode.datasets import BaseDataset, BaseConcatDataset
-from collections import defaultdict
-from pymongo import MongoClient, InsertOne, UpdateOne, DeleteOne
+from .data_utils import EEGBIDSDataset, EEGDashBaseDataset, EEGDashBaseRaw
+
 
 class EEGDash:
-    AWS_BUCKET = 's3://openneuro.org'
-    def __init__(self, 
-                 is_public=True):
+    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:
@@ -26,50 +30,52 @@ class EEGDash:
 
         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"
+            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')
+            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.__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'})
-    
+        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']
+    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):
+    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,
+            "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:
+        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():
+        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]):
@@ -78,7 +84,7 @@ class EEGDash:
         return record
 
     def load_eeg_data_from_s3(self, s3path):
-        with tempfile.NamedTemporaryFile(delete=False, suffix='.set') as tmp:
+        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
@@ -86,26 +92,23 @@ class EEGDash:
             os.unlink(tmp_path)
             return eeg_data
 
-    def load_eeg_data_from_bids_file(self,  bids_file, eeg_attrs=None):
-        '''
+    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']
+
+        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
+        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
-            },
+            dims=["channel", "time"],
+            coords={"time": time_steps, "channel": channel_names},
             # attrs=attrs
         )
         return eeg_xarray
@@ -113,22 +116,26 @@ class EEGDash:
     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
+            ".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()]
+        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}')
+            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()}
+        attrs = {field: None for field in self.config["attributes"].keys()}
 
         f = os.path.basename(bids_file)
         dsnumber = bids_dataset.dataset
@@ -141,43 +148,53 @@ class EEGDash:
         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']
+
+        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]
+                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,
+            "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:
@@ -189,14 +206,14 @@ class EEGDash:
         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')
+            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')
+        if not overwrite and self.exist({"dataset": dataset}):
+            print(f"Dataset {dataset} already exists in the database")
             return
         try:
             bids_dataset = EEGBIDSDataset(
@@ -204,24 +221,28 @@ class EEGDash:
                 dataset=dataset,
             )
         except Exception as e:
-            print(f'Error creating bids dataset {dataset}: {str(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 self.exist({"data_name": data_id}):
                     if overwrite:
-                        eeg_attrs = self.load_eeg_attrs_from_bids_file(bids_dataset, bids_file)
+                        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)
+                    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("error adding record", bids_file)
 
-        print('Number of database requests', len(requests))
+        print("Number of database requests", len(requests))
 
         if requests:
             result = self.__collection.bulk_write(requests, ordered=False)
@@ -231,25 +252,28 @@ class EEGDash:
             print(f"Upserted: {result.upserted_count}")
             print(f"Errors: {result.bulk_api_result.get('writeErrors', [])}")
 
-    def get(self, query:dict):
-        '''
+    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
+            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):
+    def add_request(self, record: dict):
         return InsertOne(record)
 
-    def add(self, record:dict):
+    def add(self, record: dict):
         try:
             # input_record = self._validate_input(record)
             self.__collection.insert_one(record)
@@ -257,38 +281,51 @@ class EEGDash:
         except ValueError as e:
             print(f"Failed to validate record: {record['data_name']}")
             print(e)
-        except: 
+        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_request(self, record: dict):
+        return UpdateOne({"data_name": record["data_name"]}, {"$set": record})
 
-    def update(self, record:dict):
+    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"]}')
+            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}})
-    
+        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}})
-    
+        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
+        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:
@@ -297,14 +334,19 @@ class EEGDashDataset(BaseConcatDataset):
             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' 
+                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))
+                    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:
@@ -315,45 +357,60 @@ class EEGDashDataset(BaseConcatDataset):
                     return result
         return None
 
-    def find_datasets(self, query:dict, description_fields:list[str], **kwargs):
+    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:
+                if value is not None:
                     description[field] = value
-            datasets.append(EEGDashBaseDataset(record, self.cache_dir, description=description, **kwargs))
+            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 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:
+                if value is not None:
                     description[field] = value
-            return EEGDashBaseDataset(record, self.cache_dir, description=description, **kwargs)
+            return EEGDashBaseDataset(
+                record, self.cache_dir, description=description, **kwargs
+            )
 
         bids_dataset = EEGBIDSDataset(
             data_dir=data_dir,
             dataset=dataset,
-            raw_format=raw_format,
         )
         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()
-            )
+            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'})
+    record = eegdash.find({"dataset": "ds005511", "subject": "NDARUF236HM7"})
     print(record)
 
-if __name__ == '__main__':
-    main()
+
+if __name__ == "__main__":
+    main()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eegdash
-Version: 0.0.9
+Version: 0.1.0
 Summary: EEG data for machine learning
 Author-email: Young Truong <dt.young112@gmail.com>, Arnaud Delorme <adelorme@gmail.com>
 License: GNU General Public License
@@ -24,29 +24,27 @@ License: 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
         
-Project-URL: Homepage, https://eegdash.org
-Project-URL: Issues, https://github.com/sccn/EEGDash/issues
+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
-Requires-Python: >=3.8
+Requires-Python: >3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: xarray
-Requires-Dist: python-dotenv
-Requires-Dist: s3fs
-Requires-Dist: mne
-Requires-Dist: pynwb
-Requires-Dist: h5py
-Requires-Dist: pymongo
-Requires-Dist: joblib
 Requires-Dist: braindecode
-Requires-Dist: mne-bids
+Requires-Dist: mne_bids
+Requires-Dist: numba
+Requires-Dist: numpy
+Requires-Dist: pandas
 Requires-Dist: pybids
-Requires-Dist: pymatreader
-Requires-Dist: pyarrow
+Requires-Dist: pymongo
+Requires-Dist: python-dotenv
+Requires-Dist: s3fs
+Requires-Dist: scipy
 Requires-Dist: tqdm
-Requires-Dist: numba
+Requires-Dist: xarray
+Requires-Dist: pre-commit
 Dynamic: license-file
 
 # EEG-Dash
@@ -90,7 +88,10 @@ To use the data from a single subject, enter:
 
 ```python
 from eegdash import EEGDashDataset
-ds_NDARDB033FW5 = EEGDashDataset({'dataset': 'ds005514', 'task': 'RestingState', 'subject': 'NDARDB033FW5'})
+
+ds_NDARDB033FW5 = EEGDashDataset(
+    {"dataset": "ds005514", "task": "RestingState", "subject": "NDARDB033FW5"}
+)
 ```
 
 This will search and download the metadata for the task **RestingState** for subject **NDARDB033FW5** in BIDS dataset **ds005514**. The actual data will not be downloaded at this stage. Following standard practice, data is only downloaded once it is processed. The **ds_NDARDB033FW5** object is a fully functional BrainDecode dataset, which is itself a PyTorch dataset. This [tutorial](https://github.com/sccn/EEGDash/blob/develop/notebooks/tutorial_eoec.ipynb) shows how to preprocess the EEG data, extracting portions of the data containing eyes-open and eyes-closed segments, then perform eyes-open vs. eyes-closed classification using a (shallow) deep-learning model. 
@@ -99,7 +100,10 @@ To use the data from multiple subjects, enter:
 
 ```python
 from eegdash import EEGDashDataset
-ds_ds005505rest = EEGDashDataset({'dataset': 'ds005505', 'task': 'RestingState'}, target_name='sex')
+
+ds_ds005505rest = EEGDashDataset(
+    {"dataset": "ds005505", "task": "RestingState"}, target_name="sex"
+)
 ```
 
 This will search and download the metadata for the task 'RestingState' for all subjects in BIDS dataset 'ds005505' (a total of 136). As above, the actual data will not be downloaded at this stage so this command is quick to execute. Also, the target class for each subject is assigned using the target_name parameter. This means that this object is ready to be directly fed to a deep learning model, although the [tutorial script](https://github.com/sccn/EEGDash/blob/develop/notebooks/tutorial_sex_classification.ipynb) performs minimal processing on it, prior to training a deep-learning model. Because 14 gigabytes of data are downloaded, this tutorial takes about 10 minutes to execute.

eegdash-0.1.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+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,,

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

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