eegdash 0.0.1__py3-none-any.whl

eegdash/SignalStore/signalstore/store/store_errors.py

@@ -0,0 +1,68 @@
+# Base Errors for the Store
+
+class StoreError(Exception):
+    """
+    Base class for all store errors
+    """
+    pass
+
+# Specific Base Errors for the Store
+# These are used to make polymorphisms
+# for the Data Access Objects and Repositories
+# so that error typing is consistent across
+# data layers
+
+class NotFoundError(StoreError):
+    """
+    Raised when a resource is not found
+    """
+    pass
+
+class AlreadyExistsError(StoreError):
+    """
+    Raised when a resource already exists
+    """
+    pass
+
+class RangeError(StoreError):
+    """
+    Raised when a resource is out of range
+    """
+    pass
+
+class ValidationError(StoreError):
+    """
+    Raised when a resource fails validation
+    """
+    pass
+
+class ArgumentTypeError(StoreError):
+    """
+    Raised when a resource fails validation
+    """
+    pass
+
+class ArgumentNameError(StoreError):
+    """
+    Raised when a resource fails validation
+    """
+    pass
+
+class ArgumentValueError(StoreError):
+    """
+    Raised when a resource fails validation
+    """
+    pass
+
+class ConfigError(StoreError):
+    """
+    Raised when a resource fails validation
+    """
+    pass
+
+class UncaughtError(StoreError):
+    """
+    Raised when a resource fails validation
+    """
+    pass
+

eegdash/SignalStore/signalstore/store/unit_of_work.py

@@ -0,0 +1,97 @@
+
+
+from abc import ABC, abstractmethod
+
+import xarray as xr
+
+class AbstractUnitOfWork(ABC):
+
+    @abstractmethod
+    def __enter__(self):
+        pass
+
+    @abstractmethod
+    def __exit__(self, type, value, traceback):
+        pass
+
+    @abstractmethod
+    def commit(self):
+        pass
+
+    @abstractmethod
+    def rollback(self):
+        pass
+
+class UnitOfWorkContextError(Exception):
+    pass
+
+class UnitOfWork:
+    def __init__(self, domain_model_repo, data_repo, in_memory_object_repo):
+        self._domain_models = domain_model_repo
+        self._data = data_repo
+        self._memory = in_memory_object_repo
+        self._in_context = False
+
+    @property
+    def domain_models(self):
+        if not self._in_context:
+            raise UnitOfWorkContextError("You must use a UnitOfWork as a context manager, i.e. use 'with unit_of_work as uow:'")
+        return self._domain_models
+
+    @property
+    def data(self):
+        if not self._in_context:
+            raise UnitOfWorkContextError("You must use a UnitOfWork as a context manager, i.e. use 'with unit_of_work as uow:'")
+        return self._data
+
+    @property
+    def memory(self):
+        if not self._in_context:
+            raise UnitOfWorkContextError("You must use a UnitOfWork as a context manager, i.e. use 'with unit_of_work as uow:'")
+        return self._memory
+
+    @property
+    def in_conxtext(self):
+        return self._in_context
+
+    def __enter__(self):
+        # reset the operations history for each repository
+        self._in_context = True
+        self._clear_operation_history()
+        return self
+
+    def __exit__(self, type, value, traceback):
+        self.rollback()
+        self._in_context = False
+
+    def rollback(self):
+        self.domain_models.undo_all()
+        self.data.undo_all()
+        self.memory.undo_all()
+
+    def commit(self):
+        operations = self._get_all_operations()
+        self._clear_operation_history()
+        return operations
+
+    def purge(self, time_threshold=None):
+        self.domain_models.purge(time_threshold)
+        self.data.purge(time_threshold)
+        self.memory.purge(time_threshold)
+
+    def _clear_operation_history(self):
+        self.domain_models.clear_operation_history()
+        self.data.clear_operation_history()
+        self.memory.clear_operation_history()
+
+    def _get_all_operations(self):
+        # (timestamp, report{operation, kwargs, result})
+        # TODO document operation_history entries more clearly
+        return {
+            'domain_models': self.domain_models._operation_history,
+            'data': self.data._operation_history,
+            'memory': self.memory._operation_history,
+        }
+
+
+

eegdash/SignalStore/signalstore/store/unit_of_work_provider.py

@@ -0,0 +1,67 @@
+from eegdash.SignalStore.signalstore.store.data_access_objects import (
+    MongoDAO,
+    FileSystemDAO,
+    InMemoryObjectDAO,
+)
+
+from eegdash.SignalStore.signalstore.store.repositories import (
+    DomainModelRepository,
+    DataRepository,
+    InMemoryObjectRepository
+)
+
+from eegdash.SignalStore.signalstore.store.datafile_adapters import (
+    AbstractDataFileAdapter,
+    XarrayDataArrayNetCDFAdapter,
+    XarrayDataArrayZarrAdapter
+)
+
+
+from eegdash.SignalStore.signalstore.store.unit_of_work import UnitOfWork
+
+class UnitOfWorkProvider:
+    def __init__(self, mongo_client, filesystem, memory_store, default_filetype='netcdf'):
+        self._mongo_client = mongo_client
+        self._filesystem = filesystem
+        self._memory_store = memory_store
+        self._default_file_type = default_filetype
+        self._file_adapter_options = {
+            'netcdf': XarrayDataArrayNetCDFAdapter(),
+            'zarr': XarrayDataArrayZarrAdapter()
+        }
+
+    def __call__(self, project_name):
+        if not isinstance(project_name, str):
+            raise ValueError("project_name must be a string")
+        model_dao = MongoDAO(client=self._mongo_client,
+                            database_name=project_name,
+                            collection_name='domain_models',
+                            index_fields=['schema_name'])
+
+        record_dao = MongoDAO(client=self._mongo_client,
+                            database_name=project_name,
+                            collection_name='records',
+                            index_fields=['schema_ref', 'data_name', 'version_timestamp']
+                            )
+
+        file_system_dao = FileSystemDAO(
+            filesystem=self._filesystem,
+            project_dir=project_name,
+            default_data_adapter=self._file_adapter_options[self._default_file_type]
+            )
+
+        in_memory_object_dao = InMemoryObjectDAO(memory_store=self._memory_store)
+
+        domain_model_repo = DomainModelRepository(model_dao=model_dao)
+
+        data_repo = DataRepository(record_dao=record_dao,
+                                file_dao=file_system_dao,
+                                domain_repo=domain_model_repo)
+
+        in_memory_object_repo = InMemoryObjectRepository(memory_dao=in_memory_object_dao)
+
+        return UnitOfWork(
+            domain_model_repo=domain_model_repo,
+            data_repo=data_repo,
+            in_memory_object_repo=in_memory_object_repo,
+        )

eegdash/SignalStore/signalstore/utilities/data_adapters/spike_interface_adapters/si_recording.py

@@ -0,0 +1 @@
+from spikeinterface.core import BaseRecording, BaseRecordingSegment

eegdash/SignalStore/signalstore/utilities/data_adapters/spike_interface_adapters/si_sorter.py

@@ -0,0 +1 @@
+from spikeinterface.sorters import BaseSorter