eegdash 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

eegdash/data_utils.py

@@ -44,7 +44,11 @@ class BIDSDataset():
             self.files = np.load(temp_dir / f'{dataset}_files.npy', allow_pickle=True)
 
     def get_property_from_filename(self, property, filename):
-        lookup = re.search(rf'{property}-(.*?)[_\/]', filename)
+        import platform
+        if platform.system() == "Windows":
+            lookup = re.search(rf'{property}-(.*?)[_\\]', filename)
+        else:
+            lookup = re.search(rf'{property}-(.*?)[_\/]', filename)
         return lookup.group(1) if lookup else ''
 
     def get_bids_file_inheritance(self, path, basename, extension):

eegdash/{aws_ingest.py → script.py}

@@ -1,15 +1,5 @@
-import sys 
-sys.path.append('..')
 import argparse
-from src.signalstore_data_utils import SignalstoreBIDS
-
-def add_bids_dataset(args):
-    signalstore_aws = SignalstoreBIDS(
-        dbconnectionstring='mongodb://23.21.113.214:27017/?directConnection=true&serverSelectionTimeoutMS=2000&appName=mongosh+2.2.1',
-        local_filesystem=False,
-        project_name='eegdash',
-    )
-    signalstore_aws.add_bids_dataset(dataset=args.dataset, data_dir=args.data, raw_format='eeglab')
+from signalstore_data_utils import SignalstoreOpenneuro
 
 def main():
     # Create the parser
@@ -23,7 +13,13 @@ def main():
     args = parser.parse_args()
     print('Arguments:', args)
 
-    add_bids_dataset(args)
+    signalstore = SignalstoreOpenneuro(
+        is_public=False,
+        local_filesystem=False,
+    )
+    hbn_datasets = ['ds005505', 'ds005510', 'ds005514','ds005512','ds005511','ds005509','ds005508','ds005507','ds005506']
+    for ds in hbn_datasets:
+        signalstore.add_bids_dataset(dataset=ds, data_dir=f'/mnt/nemar/openneuro/{ds}', raw_format='eeglab')
 
 if __name__ == "__main__":
     main()

eegdash/signalstore_data_utils.py

@@ -4,7 +4,7 @@ import re
 import numpy as np
 import xarray as xr
 import os
-from eegdash.SignalStore.signalstore.store import UnitOfWorkProvider
+from signalstore.store import UnitOfWorkProvider
 # from mongomock import MongoClient
 from pymongo.mongo_client import MongoClient
 from pymongo.server_api import ServerApi
@@ -13,8 +13,323 @@ from fsspec.implementations.dirfs import DirFileSystem
 import pandas as pd
 import json
 import s3fs
-from eegdash.data_utils import BIDSDataset
+from signalstore.store.data_access_objects import FileSystemDAO
+from .data_utils import BIDSDataset
+import tempfile
+import mne
+from joblib import Parallel, delayed
+
+class SignalstoreOpenneuro():
+    AWS_BUCKET = 'openneuro.org'
+    PROJECT_NAME = 'eegdash'
+    def __init__(self, 
+                 dbconnectionstring="mongodb://127.0.0.1:27017/?directConnection=true&serverSelectionTimeoutMS=2000&appName=mongosh+2.3.1",
+                 is_public=False,
+                 local_filesystem=True,
+                 ):
+        self.is_public = is_public
+        self.project_name = self.PROJECT_NAME
+        if is_public:
+            dbconnectionstring='mongodb+srv://eegdash-user:mdzoMjQcHWTVnKDq@cluster0.vz35p.mongodb.net/?retryWrites=true&w=majority&appName=Cluster0',
+        else:
+            load_dotenv()
+            dbconnectionstring = os.getenv('DB_CONNECTION_STRING')
+
+        # Create a new client and connect to the server
+        client = MongoClient(dbconnectionstring, server_api=ServerApi('1'))
+        # Send a ping to confirm a successful connection
+        try:
+            client.admin.command('ping')
+            print("Pinged your deployment. You successfully connected to MongoDB!")
+        except Exception as e:
+            print(e)
+
+        memory_store = {}
+        self.filesystem = self.set_up_filesystem(is_local=local_filesystem)
+        self.uow_provider = UnitOfWorkProvider(
+            mongo_client=client,
+            filesystem=self.filesystem,
+            memory_store=memory_store,
+            default_filetype='zarr'
+        )
+
+        self.uow = self.uow_provider(self.PROJECT_NAME)
+        self.load_domain_models()
+
+    def set_up_filesystem(self, is_local=True):
+        if is_local:
+            cache_path='/mnt/nemar/dtyoung/eeg-dash-data'                  # path where signalstore netCDF files are stored
+            # Create a directory for the dataset
+            store_path = Path(cache_path)
+            if not os.path.exists(store_path):
+                os.makedirs(store_path)
+
+            filesystem = LocalFileSystem()
+            tmp_dir_fs = DirFileSystem(
+                store_path,
+                filesystem=filesystem
+            )
+            return tmp_dir_fs
+        else:
+            s3 = s3fs.S3FileSystem(anon=True, client_kwargs={'region_name': 'us-east-2'})
+            return s3
+
+    def load_domain_models(self):
+        dir_path = os.path.dirname(os.path.realpath(__file__))
+        cwd = Path(dir_path)
+        domain_models_path = cwd / f"DomainModels/{self.project_name}/data_models.json"
+        metamodel_path = cwd / f"DomainModels/{self.project_name}/metamodels.json"
+        property_path = cwd / f"DomainModels/{self.project_name}/property_models.json"
+        with open(metamodel_path) as f:
+            metamodels = json.load(f)
+
+        with open(property_path) as f:
+            property_models = json.load(f)
+            
+        # load domain models json file
+        with open(domain_models_path) as f:
+            domain_models = json.load(f)
+            
+        with self.uow as uow:
+            for property_model in property_models:
+                if not uow.domain_models.exists(property_model['schema_name']):
+                    uow.domain_models.add(property_model)
+                    model = uow.domain_models.get(property_model['schema_name'])
+                    print('property model: ', model['schema_name'])
+            for metamodel in metamodels:
+                if not uow.domain_models.exists(metamodel['schema_name']):
+                    uow.domain_models.add(metamodel)
+                    model = uow.domain_models.get(metamodel['schema_name'])
+                    print('meta model: ', model['schema_name'])
+            for domain_model in domain_models:
+                if not uow.domain_models.exists(domain_model['schema_name']):
+                    uow.domain_models.add(domain_model)
+                    model = uow.domain_models.get(domain_model['schema_name'])
+                    print('domain model: ', model['schema_name'])
+                uow.commit()
+
+    def extract_attribute(self, pattern, filename):
+        match = re.search(pattern, filename)
+        return match.group(1) if match else None
+
+    def load_eeg_attrs_from_bids_file(self, bids_dataset: BIDSDataset, 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}')
+        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]
+
+        attrs = {
+            'schema_ref': 'eeg_signal',
+            'data_name': f'{bids_dataset.dataset}_{f}',
+            'dataset': bids_dataset.dataset,
+            'bidspath': openneuro_path,
+            'subject': bids_dataset.subject(bids_file),
+            'task': bids_dataset.task(bids_file),
+            'session': bids_dataset.session(bids_file),
+            'run': bids_dataset.run(bids_file),
+            'sampling_frequency': bids_dataset.sfreq(bids_file), 
+            'modality': 'EEG',
+        }
+
+        return attrs
+
+    def load_eeg_data_from_s3(self, s3path):
+        # import boto3
+        # import scipy.io
+        # import io
+
+
+        # # Initialize the S3 client
+        # s3 = boto3.client('s3')
+
+
+        # # S3 bucket and object key
+        # bucket_name = 'your-bucket-name'
+        # object_key = 'path/to/your/file.mat'
+
+
+        # # Get the object from S3 and stream it into memory
+        # response = s3.get_object(Bucket=bucket_name, Key=object_key)
+
+
+        # # Read the content into a BytesIO buffer
+        # mat_file_stream = io.BytesIO(response['Body'].read())
+
+
+        # # Load the MAT file using scipy.io.loadmat
+        # data = scipy.io.loadmat(mat_file_stream)
+
+
+        # # Work with the data
+        # print(data)
+        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 exist(self, schema_ref='eeg_signal', data_name=''):
+        with self.uow as uow:
+            query = {
+                "schema_ref": schema_ref,
+                "data_name": data_name
+            }
+            sessions = uow.data.find(query)
+            if len(sessions) > 0:
+                return True
+            else:
+                return False
+
+    def add_bids_dataset(self, dataset, data_dir, raw_format='eeglab', overwrite=False):
+        '''
+        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')
+
+        bids_dataset = BIDSDataset(
+            data_dir=data_dir,
+            dataset=dataset,
+            raw_format=raw_format,
+        )
+        for bids_file in bids_dataset.get_files():
+            print('bids raw file', bids_file)
+
+            signalstore_data_id = f"{dataset}_{os.path.basename(bids_file)}"
+            if overwrite:
+                self.remove(signalstore_data_id)
+
+            if self.exist(data_name=signalstore_data_id):
+                print('data already exist. skipped')
+                continue
+            else:
+                eeg_attrs = self.load_eeg_attrs_from_bids_file(bids_dataset, bids_file)
+                with self.uow as uow:
+                    # Assume raw data already exists on Openneuro, recreating record only
+                    eeg_attrs['has_file'] = True
+                    print('adding record', eeg_attrs['data_name'])
+                    uow.data.add(eeg_attrs)
+                    uow.commit()
+
+    def update_bids_dataset(self, dataset, data_dir, raw_format='eeglab'):
+        '''
+        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')
+
+        bids_dataset = BIDSDataset(
+            data_dir=data_dir,
+            dataset=dataset,
+            raw_format=raw_format,
+        )
+        for bids_file in bids_dataset.get_files():
+            print('bids raw file', bids_file)
+
+            signalstore_data_id = f"{dataset}_{os.path.basename(bids_file)}"
+
+            if not self.exist(data_name=signalstore_data_id):
+                raise ValueError('data not found')
+            else:
+                self.remove(data_name=signalstore_data_id)
+
+                eeg_attrs = self.load_eeg_attrs_from_bids_file(bids_dataset, bids_file)
+                with self.uow as uow:
+                    # Assume raw data already exists on Openneuro, recreating record only
+                    eeg_attrs['has_file'] = True
+                    print('adding record', eeg_attrs['data_name'])
+                    uow.data.add(eeg_attrs)
+                    uow.commit()
+
+    def remove(self, schema_ref='eeg_signal', data_name=''):
+        if self.is_public:
+            raise ValueError('This operation is not allowed for public users')
+
+        print('Removing record', data_name)
+        with self.uow as uow:
+            sessions = uow.data.find({'schema_ref': schema_ref, 'data_name': data_name})
+            if len(sessions) > 0:
+                for session in sessions:
+                    uow.data.remove(session['schema_ref'], session['data_name'])
+                    uow.commit()
+            uow.purge()
+            assert len(uow.data.find({'schema_ref': schema_ref, 'data_name': data_name})) == 0, 'Data still exists'
 
+    def remove_all(self):
+        if self.is_public:
+            raise ValueError('This operation is not allowed for public users')
+
+        with self.uow as uow:
+            sessions = uow.data.find({})
+            print(len(sessions))
+            for session in range(len(sessions)):
+                uow.data.remove(session['schema_ref'], session['data_name'])
+                uow.commit()
+
+            uow.purge()
+            
+            print('Verifying deletion job. Dataset length: ', len(uow.data.find({})))
+
+    def find(self, query:dict, validate=False):
+        '''
+        query: {
+            'dataset': 'dsxxxx',
+
+        }'''
+        with self.uow as uow:
+            sessions = uow.data.find(query, validate=validate)
+            if sessions:
+                print(f'Found {len(sessions)} records')
+                return sessions
+            else:
+                return []
+
+    def get(self, query:dict, validate=False):
+        '''
+        query: {
+            'dataset': 'dsxxxx',
+
+        }'''
+        with self.uow as uow:
+            sessions = uow.data.find(query, validate=validate)
+            results = []
+            if sessions:
+                print(f'Found {len(sessions)} records')
+                results = Parallel(n_jobs=-1, prefer="threads", verbose=1)(
+                    delayed(self.load_eeg_data_from_s3)(Path(self.AWS_BUCKET) / session['bidspath']) for session in sessions
+                )
+            return results
 
 class SignalstoreBIDS():
     AWS_BUCKET = 'eegdash'
@@ -266,6 +581,41 @@ class SignalstoreBIDS():
             else:
                 return []
 
+class OpenneuroFileSystemDAO(FileSystemDAO):
+    def __init__(self):
+        filesystem = s3fs.S3FileSystem(anon=True, client_kwargs={'region_name': 'us-east-2'})
+        super().__init__(filesystem, project_dir='openneuro.org')
+    
+    def get(self, schema_ref, data_name, version_timestamp=0, nth_most_recent=1, data_adapter=None):
+        """Gets an object from the Openneuro S3 bucket.
+        Arguments:
+            schema_ref {str} -- The type of object to get.
+            data_name {str} -- The name of the object to get.
+            version_timestamp {str} -- The version_timestamp of the object to get.
+        Raises:
+            FileSystemDAOFileNotFoundError -- If the object is not found.
+        Returns:
+            dict -- The object.
+        """
+        self._check_args(
+            schema_ref=schema_ref,
+            data_name=data_name,
+            nth_most_recent=nth_most_recent,
+            version_timestamp=version_timestamp,
+            data_adapter=data_adapter
+            )
+        if data_adapter is None:
+            data_adapter = self._default_data_adapter
+        else:
+            data_adapter.set_filesystem(self._fs)
+        path = self._get_file_path(schema_ref, data_name, version_timestamp, nth_most_recent, data_adapter)
+        if path is None:
+            return None
+        data_object = data_adapter.read_file(path)
+        data_object = self._deserialize(data_object)
+        return data_object
+    
+        
 if __name__ == "__main__":
     # sstore_hbn = SignalstoreHBN()
     # sstore_hbn.add_data()

{eegdash-0.0.1.dist-info → eegdash-0.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: eegdash
-Version: 0.0.1
+Version: 0.0.2
 Summary: EEG data for machine learning
 Author-email: Young Truong <dt.young112@gmail.com>, Arnaud Delorme <adelorme@gmail.com>
 License: GNU General Public License
@@ -32,12 +32,24 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: signalstore
 
 # 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 also incorporate data converted from NEMAR, which includes a subset of the 330 MEEG BIDS-formatted datasets available on OpenNeuro, further expanding the archive with well-curated, standardized neuroelectromagnetic data.
+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 also 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.
+
+## Datasets available
+
+There are currently only two datasets made available for testing purposes. 
+
+| Dataset ID | Description                                                                                 | Participants | Channels        | Task            | NEMAR Link                                                                                      |
+|------------|---------------------------------------------------------------------------------------------|--------------|-----------------|-----------------|------------------------------------------------------------------------------------------------|
+| ds002718   | EEG dataset focused on face processing with MRI for source localization                     | 18           | 70 EEG, 2 EOG   | FaceRecognition | [NEMAR ds002718](https://nemar.org/dataexplorer/detail?dataset_id=ds002718)                    |
+| ds004745   | 8-Channel SSVEP EEG dataset with trials including voluntary movements to introduce artifacts | 6            | 8 EEG           | SSVEP tasks     | [NEMAR ds004745](https://nemar.org/dataexplorer/detail?dataset_id=ds004745)                    |
+
+
 
 ## Data formatting
 The data in EEG-DaSh is formatted to facilitate machine learning (ML) and deep learning (DL) applications by using a simplified structure commonly adopted by these communities. This will involve converting raw MEEG data into a matrix format, where samples (e.g., individual EEG or MEG recordings) are represented by rows, and values (such as time or channel data) are represented by columns. The data is also divided into training and testing sets, with 80% of the data allocated for training and 20% for testing, ensuring a balanced representation of relevant labels across sets. Hierarchical Event Descriptor (HED) tags will be used to annotate labels, which will be stored in a text table, and detailed metadata, including dataset origins and methods. This formatting process will ensure that data is ready for ML/DL models, allowing for efficient training and testing of algorithms while preserving data integrity and reusability.
@@ -49,15 +61,70 @@ The data in EEG-DaSh is formatted to facilitate machine learning (ML) and deep l
 
 The data in EEG-DaSh is accessed through Python and MATLAB libraries specifically designed for this platform. These libraries will use objects compatible with deep learning data storage formats in each language, such as <i>Torchvision.dataset</i> in Python and <i>DataStore</i> in MATLAB. Users can dynamically fetch data from the EEG-DaSh server which is then cached locally. 
 
-### AWS S3
+### Install
+Use your preferred Python environment manager with Python > 3.9 to install the package. Here we show example using Conda environment with Python 3.11.5:
+* Create a new environment Python 3.11.5 -> `conda create --name eegdash python=3.11.5`
+* Switch to the right environment -> `conda activate eegdash`
+* Install dependencies (this is a temporary link that will be updated soon) -> `pip install -r https://raw.githubusercontent.com/sccn/EEG-Dash-Data/refs/heads/develop/requirements.txt`
+* Install _eegdash_ package (this is a temporary link that will be updated soon) -> `pip install -i https://test.pypi.org/simple/ eegdash`
+* Check installation. Start a Python session and type `from eegdash import EEGDash`
+
+### Python data access
+
+To create a local object for accessing the database, use the following code:
+
+```python
+from eegdash import EEGDash
+EEGDashInstance = EEGDash()
+```
+
+Once the object is instantiated, it can be utilized to search datasets. Providing an empty parameter will search the entire database and return all available datasets.
+
+```python
+EEGDashInstance.find({})
+```
+A list of dataset is returned.
+
+```python
+[{'schema_ref': 'eeg_signal',
+  'data_name': 'ds004745_sub-001_task-unnamed_eeg.set',
+  'dataset': 'ds004745',
+  'subject': '001',
+  'task': 'unnamed',
+  'session': '',
+  'run': '',
+  'modality': 'EEG',
+  'sampling_frequency': 1000,
+  'version_timestamp': 0,
+  'has_file': True,
+  'time_of_save': datetime.datetime(2024, 10, 25, 14, 11, 48, 843593, tzinfo=datetime.timezone.utc),
+  'time_of_removal': None}, ...
+
+```
+
+Additionally, users can search for a specific dataset by specifying criteria.
+
+```python
+EEGDashInstance.find({'task': 'FaceRecognition'})
+```
+
+After locating the desired dataset or data record, users can download it locally by executing the following command:
+
+```python
+EEGDashInstance.get({'task': 'FaceRecognition', 'subject': '019'})
+```
+
+Optionally, this is how you may access the raw data for the first record.
 
-Coming soon...
+```python
+EEGDashInstance.get({'task': 'FaceRecognition', 'subject': '019'})[0].values
+```
 
-### EEG-Dash API
+## Example use
 
-Coming soon...
+This [example](tests/eegdash.ipynb) demonstrates the full workflow from data retrieval with `EEGDash` to model definition, data handling, and training in PyTorch.
 
-## Education
+## Education - Coming soon...
 
 We organize workshops and educational events to foster cross-cultural education and student training, offering both online and in-person opportunities in collaboration with US and Israeli partners. There is no event planned for 2024. Events for 2025 will be advertised on the EEGLABNEWS mailing list so make sure to [subscribe](https://sccn.ucsd.edu/mailman/listinfo/eeglabnews).
 

eegdash-0.0.2.dist-info/RECORD

@@ -0,0 +1,10 @@
+eegdash/__init__.py,sha256=hgxE8COvPu3EV2Tq3GqtMk68fsd7bYvOs_0GO6rrzfk,32
+eegdash/data_utils.py,sha256=CA4lC5MKSoxCp0uJWy_n2okGtTCof2svDzSGxHZcIo0,9080
+eegdash/main.py,sha256=ANyrsVCvDiKNiQAmlQt9FcyOeCoD4Oe6Gq25LM2o38o,675
+eegdash/script.py,sha256=IbxGybE9Bpx0fS9QEw2YMYkakARYsEFelH-xfzlPQxU,974
+eegdash/signalstore_data_utils.py,sha256=g4nSYBIR5obhlKCC1erH4C_KrmuaGVu_JJpcC59yRMY,24198
+eegdash-0.0.2.dist-info/LICENSE,sha256=Xafu48R-h_kyaNj2tuhfgdEv9_ovciktjUEgRRwMZ6w,812
+eegdash-0.0.2.dist-info/METADATA,sha256=rreskaKqIRA0bBmHJOpwQpFLxTX9oX_YCZpk5yd1wBs,9335
+eegdash-0.0.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+eegdash-0.0.2.dist-info/top_level.txt,sha256=zavO69HQ6MyZM0aQMR2zUS6TAFc7bnN5GEpDpOpFZzU,8
+eegdash-0.0.2.dist-info/RECORD,,

{eegdash-0.0.1.dist-info → eegdash-0.0.2.dist-info}/WHEEL

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

eegdash/SignalStore/signalstore/__init__.py

@@ -1,3 +0,0 @@
-from eegdash.SignalStore.signalstore.store.unit_of_work_provider import UnitOfWorkProvider
-
-__all__ = ['UnitOfWorkProvider']

eegdash/SignalStore/signalstore/adapters/read_adapters/abstract_read_adapter.py

@@ -1,13 +0,0 @@
-from abc import ABC, abstractmethod
-
-class AbstractReadAdapter(ABC):
-
-    def __iter__(self):
-        return self.read().__iter__()
-
-    def __next__(self):
-        return self.read().__next__()
-
-    @abstractmethod
-    def read(self):
-        raise NotImplementedError('AbstractReadAdapter.read() not implemented.')

eegdash/SignalStore/signalstore/adapters/read_adapters/domain_modeling/schema_read_adapter.py

@@ -1,16 +0,0 @@
-from signalstore.adapters.read_adapters.abstract_read_adapter import AbstractReadAdapter
-import json
-from upath import UPath
-
-class SchemaReadAdapter(AbstractReadAdapter):
-    def __init__(self, directory):
-        self.dir = UPath(directory)
-
-    def read(self):
-        """Reads JSON files that conform to the Neuroscikit data model schemata.
-        """
-        for json_filepath in self.dir.glob('*.json'):
-            with open(json_filepath) as f:
-                yield dict(json.load(f))
-
-

eegdash/SignalStore/signalstore/adapters/read_adapters/domain_modeling/vocabulary_read_adapter.py

@@ -1,19 +0,0 @@
-from signalstore.adapters.read_adapters.abstract_read_adapter import AbstractReadAdapter
-
-import yaml
-
-class VocabularyReadAdapter(AbstractReadAdapter):
-    def __init__(self, filepath):
-        self.filepath = filepath
-
-    def read(self):
-        """Reads a YAML file and converts each data object into an xarray.DataArray with
-        the appropriate dimensions, coordinates and metadata attributes for the
-        Neuroscikit data model.
-        """
-        with open(self.filepath) as f:
-            yaml_dict = yaml.load(f, Loader=yaml.FullLoader)
-        for key, value in yaml_dict.items():
-            record = {"name": key}
-            record.update(value)
-            yield record