eegdash 0.0.1__py3-none-any.whl

eegdash/SignalStore/signalstore/__init__.py

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

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

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

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

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

eegdash/SignalStore/signalstore/adapters/read_adapters/handmade_records/excel_study_organizer_read_adapter.py

@@ -0,0 +1,114 @@
+from signalstore.operations.importers.adapters.abstract_read_adapter import AbstractReadAdapter
+
+import openpyxl as xl
+
+class ExcelStudyOrganizerReadAdapter(AbstractReadAdapter):
+    def __init__(self, path):
+        self.path = path
+        self.wb = xl.load_workbook(path)
+        self.ws = self.wb.active
+        self.tables = [str(table) for table in self.wb.sheetnames]
+
+    def read(self):
+        for table in self.tables:
+            for record in self._get_table_records(table):
+                yield record
+
+    def read_records(self):
+        records = []
+        for table in self.tables:
+            records.extend(list(self._get_table_records(table)))
+        return records
+
+    def read_records_by_table(self):
+        records = {}
+        for table in self.tables:
+            records[str(table).lower()] = list(self._get_table_records(table))
+        return records
+
+    def _classify_table(self, table):
+        # check if name column is unique
+        has_unique_keys = self._has_unique_keys(table)
+
+        # check if the table columns include only the name column,
+        # an attribute column and a value column
+        is_attr_value_format = self._is_attr_value_format(table)
+
+        if not has_unique_keys and is_attr_value_format:
+            return 'attribute'
+        elif has_unique_keys and not is_attr_value_format:
+            return 'record'
+        else:
+            error_string = f'Could not classify table {table}.'
+            if not has_unique_keys:
+                error_string += '\nTable does not have unique keys.'
+            if not is_attr_value_format:
+                error_string += '\nTable is not in attribute-value format.'
+            raise StudyOrganizerKeyError(error_string)
+
+    def _has_unique_keys(self, table):
+        ws = self.wb[table]
+        keys = [str(cell.value).lower() for cell in ws['A'] if cell.value is not None]
+        return len(keys) == len(set(keys))
+
+    def _is_attr_value_format(self, table):
+        ws = self.wb[table]
+        columns = [str(cell.value).lower() for cell in ws[1]]
+        if columns[0] == f'name' and columns[1] == 'attribute' and columns[2] == 'value' and len(columns) == 3:
+            return True
+        else:
+            return False
+
+    def _get_table_records(self, table):
+        table_type = self._classify_table(table)
+        readers = {'record': self._get_simple_table_records,
+                   'attribute': self._get_attribute_table_records}
+        records = readers[table_type](table)
+        for record in records:
+            yield record
+
+    def _get_simple_table_records(self, table):
+        self.ws = self.wb[table]
+        columns = [str(cell.value).lower() for cell in self.ws[1]]
+        self._validate_columns(columns, table)
+        for row in self.ws.iter_rows(min_row=2):
+            record = {}
+            for i, column in enumerate(columns):
+                value = row[i].value
+                if value is not None:
+                    record[column] = value
+            if record != {}:
+                record['type'] = table
+                yield record
+
+    def _get_attribute_table_records(self, table):
+        self.ws = self.wb[table]
+        columns = [str(cell.value).lower() for cell in self.ws[1]]
+        self._validate_columns(columns, table)
+        attr_records = []
+        for row in self.ws.iter_rows(min_row=2):
+            record = {}
+            for i, column in enumerate(columns):
+                record[column] = row[i].value
+            attr_records.append(record)
+        records = {}
+        for attr_record in attr_records:
+            rkey = attr_record['name']
+            if rkey not in records.keys() and rkey is not None:
+                records[rkey] = {'name': rkey, 'type': table}
+            if attr_record['value'] is not None:
+                records[rkey][attr_record['attribute']] = attr_record['value']
+        for record in records.values():
+            if record != {}:
+                yield record
+
+    def _validate_columns(self, columns, table_name):
+        if not self._first_column_is_key(columns, table_name):
+            raise StudyOrganizerKeyError(f'First column must be a "name" column, but is {columns[0]}.')
+
+    def _first_column_is_key(self, columns, table_name):
+        return str(columns[0]) == f'name'
+
+
+class StudyOrganizerKeyError(KeyError):
+    pass