pytour 3.0.0.dev4__tar.gz

pytour-3.0.0.dev4/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Jin Dou
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pytour-3.0.0.dev4/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: pytour
+Version: 3.0.0.dev4
+Home-page: https://github.com/powerfulbean/pytour
+Author: Powerfulbean
+Author-email: powerfulbean@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mne
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+
+# tour
+A framework for boosting the implementation of stimulus-response research code in the field of cognitive science and neuroscience 

pytour-3.0.0.dev4/README.md

@@ -0,0 +1,2 @@
+# tour
+A framework for boosting the implementation of stimulus-response research code in the field of cognitive science and neuroscience 

pytour-3.0.0.dev4/pytour.egg-info/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: pytour
+Version: 3.0.0.dev4
+Home-page: https://github.com/powerfulbean/pytour
+Author: Powerfulbean
+Author-email: powerfulbean@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mne
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+
+# tour
+A framework for boosting the implementation of stimulus-response research code in the field of cognitive science and neuroscience 

pytour-3.0.0.dev4/pytour.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+setup.py
+pytour.egg-info/PKG-INFO
+pytour.egg-info/SOURCES.txt
+pytour.egg-info/dependency_links.txt
+pytour.egg-info/requires.txt
+pytour.egg-info/top_level.txt
+tests/test_dataset.py
+tour/__init__.py
+tour/artifacts_removal.py
+tour/package_manage.py
+tour/vis.py
+tour/dataclass/__init__.py
+tour/dataclass/dataset.py
+tour/dataclass/io.py

pytour-3.0.0.dev4/pytour.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pytour-3.0.0.dev4/pytour.egg-info/requires.txt

@@ -0,0 +1,4 @@
+mne
+numpy
+scipy
+matplotlib

pytour-3.0.0.dev4/pytour.egg-info/top_level.txt

@@ -0,0 +1 @@
+tour

pytour-3.0.0.dev4/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pytour-3.0.0.dev4/setup.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Sat Aug 31 00:52:16 2019
+
+@author: Jin Dou
+"""
+
+import setuptools
+import re
+
+with open("./README.md", "r") as fh:
+  long_description = fh.read()
+
+with open("tour/__init__.py") as file:
+    for line in file.readlines():
+        m = re.match("__version__ *= *['\"](.*)['\"]", line)
+        if m:
+            version = m.group(1)
+
+setuptools.setup(
+  name="pytour",
+  version=version,
+  author="Powerfulbean",
+  author_email="powerfulbean@gmail.com",
+  long_description=long_description,
+  long_description_content_type="text/markdown",
+  url="https://github.com/powerfulbean/pytour",
+  packages=setuptools.find_packages(),
+  classifiers=[
+      "Programming Language :: Python :: 3",
+      "License :: OSI Approved :: MIT License",
+      "Operating System :: OS Independent",
+  ],
+  install_requires=[
+      "mne",
+      "numpy",
+      "scipy",
+      "matplotlib",
+  ],
+)

pytour-3.0.0.dev4/tests/test_dataset.py

@@ -0,0 +1,36 @@
+import os
+import mne
+import h5py
+import json
+import numpy as np
+from collections import OrderedDict
+from StellarInfra import siIO
+from tray.dataclass.io import (
+    mne_montage_to_h5py_group,
+    mne_montage_from_h5py_group
+)
+
+current_folder = os.path.dirname(os.path.abspath(__file__))
+
+def test_save_mne_montage():
+    output_fd = os.environ['box_root']
+    montage = mne.channels.make_standard_montage('biosemi128')
+    fig = montage.plot(show = False)
+    fig.savefig(f"{current_folder}/target_montage.png")
+    pos_dict = montage.get_positions()
+    with h5py.File(f"{output_fd}/Collab-Project/CompiledDataset/biosemi128_montage.h5", "w") as f:
+        mne_montage_to_h5py_group(pos_dict, f)
+    
+def test_load_montage_in_mne():
+    output_fd = os.environ['box_root']
+    with h5py.File(f"{output_fd}/Collab-Project/CompiledDataset/biosemi128_montage.h5", "r") as f:
+        montage = mne_montage_from_h5py_group(f)
+    fig = montage.plot(show = False)
+    fig.savefig(f"{current_folder}/loaded_montage.png")
+
+
+data_path = f"{os.environ['box_root']}/Collab-Project/CompiledDataset/ns.pkl"
+dataset = siIO.loadObject(data_path)
+print(dataset)
+# test_save_mne_montage()
+# test_load_montage_in_mne()

pytour-3.0.0.dev4/tour/__init__.py

@@ -0,0 +1 @@
+__version__ = "3.0.0.dev4"

pytour-3.0.0.dev4/tour/artifacts_removal.py

@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Jul  8 14:41:55 2021
+
+@author: Jin Dou
+"""
+import mne
+import numpy as np
+from scipy.stats import zscore
+
+def mneWrap_lalorlab_detect_EEG_badChannels(mneraw:mne.io.RawArray, montage = None, nNearest = 10):
+    oRaw = mneraw.copy()
+    data = oRaw.get_data()
+    if montage is None:
+        badChansIdx = lalorlab_detect_EEG_badChannels(data,False)
+    else:
+        badChansIdx = lalorlab_detect_EEG_badChannels_covVarNear(data,montage, nNearest = nNearest)
+    oRaw.info['bads'] = [oRaw.info['ch_names'][i] for i in badChansIdx]
+    print(f'bad channels: {",".join(oRaw.info["bads"])}')
+    return oRaw
+
+
+def lalorlab_detect_EEG_badChannels(eegarray,verbose = True):
+    '''
+    we assume the first dimension is channel dimension
+
+    Parameters
+    ----------
+    eegarray : TYPE
+        DESCRIPTION.
+
+    Returns
+    -------
+    None.
+
+    '''
+    eegarray = np.array(eegarray)
+    assert len(eegarray.shape) == 2 
+    stdChans = list()
+    badChansIdx = list()
+    for chan in eegarray:
+        stdChans.append(np.std(chan))
+    
+    for idx,chan in enumerate(eegarray):
+        if np.std(chan) > 2.5 * np.mean(stdChans):
+            badChansIdx.append(idx)
+        
+    stdChans.clear()
+    
+    for idx,chan in enumerate(eegarray):
+        if idx not in badChansIdx:
+            stdChans.append(np.std(chan))
+    
+    for idx,chan in enumerate(eegarray):
+        if np.std(chan) < np.mean(stdChans) / 2.5:
+            badChansIdx.append(idx)
+        
+    if verbose:
+        print(badChansIdx)
+    
+    return badChansIdx
+
+def lalorlab_detect_EEG_badChannels_covVarNear(data, montage, th1 = 2, th2 = 2, nNearest = 6):
+    # data: (nChan, nSamples)
+    data = np.array(data)
+    assert data.ndim == 2
+    
+    ### prepare the nearest channels
+    if nNearest > 0:
+        chanloc = montage.get_positions()['ch_pos']
+        chnames = []
+        poses = []
+        for n,pos in chanloc.items():
+            chnames.append(n)
+            poses.append(pos)
+            
+        assert data.shape[0] == len(chnames)
+        chanDistMat = np.zeros((len(chanloc), len(chanloc)))
+        
+        fDist = lambda pos1,pos2: np.sqrt(np.sum((pos1 - pos2)**2))
+        
+        for i in range(len(chnames)):
+            for j in range(len(chnames)):
+                chanDistMat[i,j] = fDist(poses[i], poses[j])
+        
+        nearChanIdx = []
+        for i in range(len(chnames)):
+            nearChanIdx.append(np.argsort(chanDistMat[i])[1:nNearest+1])
+    else:
+        nearChanIdx = [None] * data.shape[1]
+    ### find the bad channels
+    dataz = zscore(data, axis = 1)
+    XTX = np.matmul(dataz ,dataz.T)
+    stdXTX = np.std(XTX, axis = 1)
+    stdEEG = np.std(data, axis = 1)
+    
+    badChans = []
+    if nNearest <=0 :
+        badChans.append(np.where(stdXTX < np.mean(stdXTX) / th1))
+        badChans.append(np.where(stdEEG > np.mean(stdEEG) * th2))
+    else:
+        for chanIdx in range(data.shape[0]):
+            # print(stdXTX[chanIdx],
+            #       stdEEG[chanIdx],
+            #       np.mean(stdXTX[nearChanIdx[chanIdx]]) / th1,
+            #       np.mean(stdEEG[nearChanIdx[chanIdx]]) * th2)
+            if stdXTX[chanIdx] < np.mean(stdXTX[nearChanIdx[chanIdx]]) / th1:
+                badChans.append(chanIdx)
+            if stdEEG[chanIdx] > np.mean(stdEEG[nearChanIdx[chanIdx]]) * th2:
+                badChans.append(chanIdx)
+            
+    return list(set(badChans))
+    
+def plotChanWithNamesAtIdx(montage, idxs):
+    chnames = montage.ch_names
+    montage.plot(show_names = [chnames[idx] for idx in idxs])
+    
+            
+# def      
+        
+    
+        

pytour-3.0.0.dev4/tour/dataclass/dataset.py

@@ -0,0 +1,404 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Jan 16 12:44:20 2025
+
+@author: jdou3
+"""
+import re
+import io
+import copy
+import h5py
+import json
+import itertools
+# import h5py
+from typing import List
+import numpy as np
+
+from .io import (
+    data_record_from_h5py_group, data_record_to_h5py_group
+)
+
+#Note: please don't change the order, it matters for some functions using it
+META_INFO_FORCED_FIELD = ['dataset_name', 'subj_id', 'trial_id'] 
+
+
+def flatten_list_of_lists(list_of_lists:List[List]):
+    return list(itertools.chain.from_iterable(list_of_lists))
+
+def k_folds(n_trials, n_folds):
+    id_trials = np.arange(n_trials)
+    splits = np.array_split(id_trials, n_folds)
+    for split_idx in range(len(splits)):
+        # print('cv fold', split_idx)
+        idx_val = splits[split_idx]
+        idx_train = np.concatenate(splits[:split_idx] + splits[split_idx + 1 :])
+        yield idx_train, idx_val
+
+def _validate_stimuli_dict(stimuli_dict:dict):
+    for k in stimuli_dict:
+        stim:dict = stimuli_dict[k]
+        if not isinstance(stim, dict):
+            raise ValueError(f'value for stim {k} should be a dict')
+        for feat_k, feat_v in stim.items():
+            if isinstance(feat_v, dict):
+                assert all([s in feat_v for s in ['x', 'timeinfo', 'tag']])
+            else:
+                pass
+                # pattern = r"_fs\d+$"
+                # assert re.search(pattern, feat_k)
+    return stimuli_dict   
+
+def _validate_meta_info(info:dict):
+    assert all([k in info for k in META_INFO_FORCED_FIELD])
+    for k, v in info.items():
+        if isinstance(v, np.integer):
+            info[k] = int(v)
+    for k,v in info.items():
+        assert isinstance(v, ((str, int, float, np.ndarray))), f"{k},{type(v)}"
+    return info
+
+def align_data(*arrs):
+    arrs = list(arrs)
+    #assume arr have shape [nChannel, nSamples]
+    minLen  = min([arr.shape[1] for arr in arrs])
+    for i, arr in enumerate(arrs):
+        arrs[i] = arr[:, :minLen]
+    return arrs
+     
+def i_split_kfold(tarList,cur_fold,n_folds, add_dev = True):
+    ''' curFold starts from zero '''
+    kfList = [i for i in k_folds(len(tarList), n_folds)]
+    curTrainDevIdx = kfList[cur_fold][0]
+    curTestIdx = kfList[cur_fold][1]
+    curDevIdx = kfList[(cur_fold + 1) % n_folds][1]
+    if add_dev:
+        curTrainIdx = [i for i in curTrainDevIdx if i not in curDevIdx]
+        curTrain = [tarList[i] for i in curTrainIdx]
+        curDev = [tarList[i] for i in curDevIdx]
+        curTest = [tarList[i] for i in curTestIdx]
+        return curTrain, curDev, curTest 
+    else:
+        curTrainDev = [tarList[i] for i in curTrainDevIdx]
+        curTest = [tarList[i] for i in curTestIdx]
+        return curTrainDev, [], curTest
+
+def k_fold(dataset:'Dataset', cur_fold, n_folds, split_by = 'trial_id', add_dev = True, if_shuffle = False, seed = 42):
+    info_sets = sorted(
+        list(set(
+            [i.meta_info[split_by] for i in dataset.records]
+    )))
+    if if_shuffle:
+        rng = np.random.default_rng(seed)
+        inf_idxs = np.arange(len(info_sets))
+        rng.shuffle(inf_idxs)
+        info_sets = [info_sets[idx_] for idx_ in inf_idxs]
+    info_train_list, info_dev_list, info_test_list = i_split_kfold(
+        info_sets, cur_fold, n_folds, add_dev)
+    print(info_train_list, info_dev_list, info_test_list)
+    output = {}
+    output['train'] = dataset.subset_by_info({split_by:info_train_list})
+    if len(info_dev_list) > 0:
+        output['dev'] = dataset.subset_by_info({split_by:info_dev_list})
+    output['test'] = dataset.subset_by_info({split_by:info_test_list})
+    return output
+
+
+def dump_dict_contains_nparray(state_dict):
+    output = {}
+    for key, value in state_dict.items():
+        if isinstance(value, np.ndarray):
+            buffer = io.BytesIO()
+            np.save(buffer, value)
+            t_value = buffer.getvalue()
+        elif isinstance(value, dict):
+            # print(key)
+            t_value = dump_dict_contains_nparray(value)
+        else:
+            t_value = value
+        output[key] = t_value
+    return output
+
+def load_dict_contains_nparray(state_dict):
+    new_state = {}
+    for k,v in state_dict.items():
+        if isinstance(v, bytes):
+            buffer = io.BytesIO(v)
+            new_state[k] = np.load(buffer)
+            # new_state[k] = np.frombuffer(v)
+        elif isinstance(v, dict):
+            # print(k)
+            new_state[k] = load_dict_contains_nparray(v)
+        else:
+            new_state[k] = v
+    return new_state
+
+class DataRecord:
+    
+    def __init__(self, data, stim_id, meta_info:dict, srate:int):
+        self.srate = srate
+        self.data = data
+        self.stim_id = stim_id
+        self.meta_info = _validate_meta_info(meta_info)
+
+    def dump_to_dict(self):
+        return dump_dict_contains_nparray(self.__dict__)
+    
+    def dump(self):
+        record_key = "-".join(
+            [str(self.meta_info[k]) for k in META_INFO_FORCED_FIELD]
+        )
+        return dict(
+            key = record_key,
+            data = self.data,
+            stim_id = self.stim_id,
+            meta_info = self.meta_info,
+            srate = self.srate,
+        )
+
+    @classmethod
+    def load(cls, new_state:dict):
+        obj = cls(**new_state)
+        return obj
+
+    @classmethod
+    def load_from_dict(cls, state:dict):
+        new_state = load_dict_contains_nparray(state)
+        obj = cls(**new_state)
+        # for key in state:
+            # obj.__dict__[key] = state[key]
+        return obj
+    
+    def copy(self):
+        new = DataRecord(
+            self.data.copy(),
+            self.stim_id,
+            copy.deepcopy(self.meta_info),
+            self.srate
+        )
+        return new 
+
+class Dataset:
+    
+    # data and stim have the shape (nChannels, nSamples)
+    # stim_id_cond: used when stimuli contains multiple conditions
+    
+    def __init__(self, name:str, srate:int):
+        self.name = name
+        self.srate = srate
+        self.stim_feat_filter:list = []
+        self.resp_chan_filter:list = []
+        self.stim_id_cond:str|None = None
+        self.meta_info_filter:dict = {}
+        self._stimuli_dict:dict = {}
+        self._records:List[DataRecord] = []
+        self._preprocess_config = {}
+    
+    def copy(self):
+        new_dataset = Dataset(
+            self.name,
+            self.srate
+        )
+        new_dataset.stim_feat_filter = copy.deepcopy(self.stim_feat_filter)
+        new_dataset.resp_chan_filter = copy.deepcopy(self.resp_chan_filter)
+        new_dataset.stim_id_cond = copy.deepcopy(self.stim_id_cond)
+        new_dataset.meta_info_filter = copy.deepcopy(self.meta_info_filter)
+        new_dataset._stimuli_dict = self._stimuli_dict
+        new_dataset._records = [r_.copy() for r_ in self._records]
+        return new_dataset
+
+    @property    
+    def stimuli_dict(self):
+        return self._stimuli_dict
+    
+    @stimuli_dict.setter
+    def stimuli_dict(self, x):
+        self._stimuli_dict = _validate_stimuli_dict(x)
+    
+    @property
+    def records(self) -> List[DataRecord]:
+        if len(self.meta_info_filter) == 0:
+            return self._records
+        else:
+            return self._filter_records_by_info(self._records, self.meta_info_filter)
+    
+    def _filter_records_by_info(self, records, meta_info_filter:dict):
+        output = list()
+        for record in records:
+            if all(
+                    [
+                        record.meta_info[k] == v if np.isscalar(v) 
+                            else record.meta_info[k] in v 
+                                for k,v in meta_info_filter.items()
+                    ]
+            ):
+                output.append(record)
+        return output
+    
+    def append(self, record:DataRecord):
+        assert record.srate == self.srate
+        self._records.append(record)
+
+    def _filter_stim_feat(self, stim_feat):
+        new_stim_feat = {}
+        if len(self.stim_feat_filter) == 0:
+            stim_feat_filter = stim_feat.keys()
+        else:
+            stim_feat_filter = self.stim_feat_filter
+        for i in stim_feat_filter:
+            new_stim_feat[i] = stim_feat[i]
+        return new_stim_feat
+    
+    def _filter_resp_chan(self, resp):
+        if len(self.resp_chan_filter) > 0:
+            idxArr = np.array(self.resp_chan_filter)
+            output = resp[idxArr,:]
+        else:
+            output = resp
+        return output
+
+    def __getitem__(self, idx):
+        record:DataRecord = self.records[idx]
+        return self._unpack_record(record)
+        
+    def _unpack_record(self, record:DataRecord):
+        stim_id, data = record.stim_id, record.data
+        if isinstance(stim_id, dict):
+            assert self.stim_id_cond is not None
+            stim_id = stim_id[self.stim_id_cond]
+        stim_feat = self._filter_stim_feat(self.stimuli_dict[stim_id])
+        data = self._filter_resp_chan(data)
+        return stim_feat, data, record.meta_info
+    
+    def __len__(self):
+        return len(self.records)
+    
+    def __iter__(self):
+        self.n = 0
+        return self
+    
+    def __next__(self):
+        if self.n  < len(self.records):
+            self.n += 1
+            return self.__getitem__(self.n-1)#self.records[self.n-1]
+        else:
+            raise StopIteration
+    
+    def to_pairs(self, ifT = True):
+        allSubj = set([i.meta_info['subj_id'] for i in self.records])
+        filterKey = lambda x: x.meta_info['subj_id']
+        sortKey = lambda x : (
+            x.meta_info['dataset_name'],
+            x.meta_info['subj_id'], 
+            x.meta_info['trial_id'], 
+        )
+        
+        records = sorted(self.records, key = sortKey)
+        
+        transpose = lambda *arrs: [arr.T for arr in arrs]
+        def catstimarr(stim:dict):
+            keys = stim.keys()
+            # print(keys)
+            assert all([stim[k].shape[0] < stim[k].shape[1] for k in keys if isinstance(stim[k], np.ndarray)])
+            stim = [stim[k] for k in keys if isinstance(stim[k], np.ndarray)]
+            stim = align_data(*stim)
+            stim = np.concatenate(stim, axis = 0)
+            # print(stim.shape)
+            return stim
+
+        stims_subj = []
+        resps_subj = []
+        infoss = []
+        ks = []
+        for k, grp in itertools.groupby(records, filterKey):
+            stims, resps, infos = list(zip(*[self._unpack_record(g) for g in grp]))
+            # print(infos)
+            stims = list(map(catstimarr, stims))
+            stims, resps = list(zip(*map(align_data, stims, resps)))
+            if ifT:
+                stims, resps = list(zip(*map(transpose, stims, resps)))
+            stims_subj.append(stims)
+            resps_subj.append(resps)
+            infoss.append(infos)
+            ks.append(k)
+
+        return stims_subj, resps_subj, ks, infoss
+    
+    def to_pairs_iter(self,sortKey = None):
+        allSubj = set([i.meta_info['subj_id'] for i in self.records])
+        
+        filterKey = lambda x: x.meta_info['subj_id']
+        if sortKey is None:
+            sortKey = lambda x : (
+                x.meta_info['dataset_name'],
+                x.meta_info['subj_id'], 
+                x.meta_info['trial_id'], 
+            )
+        
+        records = sorted(self.records, key = sortKey)
+
+        for k, grp in itertools.groupby(records, filterKey):
+            stims, resps, infos = list(zip(*[self._unpack_record(g) for g in grp]))
+            yield stims, resps, infos, k
+
+
+
+    def k_fold(self, cur_fold, n_folds, split_by, add_dev = True, if_shuffle = False):
+        return k_fold(self, cur_fold, n_folds, split_by, add_dev=add_dev, if_shuffle = if_shuffle)
+    
+    def subset_by_info(self,meta_info_filter):
+        records = self._filter_records_by_info(
+            self._records, meta_info_filter)
+        state_dict = self.dump()
+        state_dict['_records'] = [l.dump() for l in records]
+        return self.__class__.load(state_dict)
+
+    def dump(self, file_path):
+        with h5py.File(file_path, "w") as f:
+            f.attrs["name"] = self.name
+            f.attrs["srate"] = self.srate
+            preprocess_config = json.dumps(self._preprocess_config)
+            f.attrs["preprocess_config_str"] = preprocess_config
+            for record in self._records:
+                data_record_to_h5py_group(
+                    f = f,
+                    **record.dump(),
+                )
+    
+    @classmethod
+    def load(cls, file_path):
+        new_dataset = None
+        with h5py.File(file_path, "r") as f:
+            new_dataset = cls(
+                name = str(f.attrs['name']),
+                srate = int(f.attrs['srate']),
+            )
+            for k, grp in f['records'].items():
+                record_dict = data_record_from_h5py_group(grp)
+                new_record = DataRecord(**record_dict)
+                new_dataset.append(new_record)
+        return new_dataset
+
+    def dump_to_dict(self):
+        output = {}
+        output['_records'] = [l.dump() for l in self._records]
+        for k,v in self.__dict__.items():
+            if k != '_records':
+                if isinstance(v, dict):
+                    output[k] = dump_dict_contains_nparray(v)
+                else:
+                    output[k] = v
+        return output
+
+    @classmethod
+    def load_from_dict(cls, state):
+        output = cls(name = state['name'], srate = state['srate'])
+        for k,v in state.items():
+            if k == '_records':
+                output.__dict__['_records'] = [DataRecord.load(l) for l in state[k]]
+            else:
+                if isinstance(v, dict):
+                    output.__dict__[k] = load_dict_contains_nparray(v)
+                else:
+                    output.__dict__[k] = state[k]
+        return output
+            

pytour-3.0.0.dev4/tour/dataclass/io.py

@@ -0,0 +1,101 @@
+import os
+import mne
+import h5py
+import json
+import numpy as np
+from collections import OrderedDict
+from typing import Union
+"""
+ mne montage data class related
+"""
+
+def mne_montage_to_h5py_group(montage:mne.channels.DigMontage, f:h5py.File):
+    montage_grp = f.require_group('montage')
+    pos_dict = montage.get_positions()
+    for k,v in pos_dict.items():
+        # print(k)
+        if k == 'ch_pos':
+            chs, ch_coords = list(zip(
+                *[
+                    (ch, ch_coord) 
+                for ch, ch_coord in v.items()
+            ]))
+            ch_coords = np.stack(ch_coords)
+            chs_json_str = json.dumps(chs)
+            # print(chs_json_str)
+            t_ds = montage_grp.create_dataset(k, data = ch_coords)
+            t_ds.attrs['chs_json_str'] = chs_json_str
+        elif k == 'coord_frame':
+            montage_grp.attrs['coord_frame'] = v
+        else:
+            if v is None:
+                v = np.array([])
+            montage_grp.create_dataset(k, data = v)
+    return f
+    
+def mne_montage_from_h5py_group(f:h5py.File):
+    pos_dict = {}
+    montage_grp = f['montage']
+    for k, v in montage_grp.items():
+        if k == 'ch_pos':
+            t_dict = OrderedDict()
+            t_ds = montage_grp[k]
+            ch_coords = t_ds[:]
+            chs = json.loads(t_ds.attrs['chs_json_str'])
+            for i_ch, ch in enumerate(chs):
+                t_dict[ch] = ch_coords[i_ch]
+            pos_dict[k] = t_dict
+        else:
+            # print(v.shape)
+            if v.shape == (0,):
+                pos_dict[k] = None
+            else:
+                pos_dict[k] = v[:]
+    pos_dict['coord_frame'] = montage_grp.attrs['coord_frame']
+    montage = mne.channels.make_dig_montage(**pos_dict)
+    return montage
+
+
+"""
+ tray DataRecord class related
+"""
+def data_record_to_h5py_group(
+    key: str,
+    data: np.ndarray,
+    stim_id: Union[str, int],
+    meta_info:dict,
+    srate: int,
+    f:h5py.File
+):
+    root_grp = f.require_group(f'records/{key}')
+    root_grp.create_dataset('data', data = data)
+    root_grp.attrs['stim_id'] = stim_id
+    root_grp.attrs['srate'] = srate
+
+    meta_info_grp = root_grp.require_group('meta_info')
+    for k,v in meta_info.items():
+        if isinstance(v, np.ndarray):
+            meta_info_grp.create_dataset(k, data=v)
+        else:
+            meta_info_grp.attrs[k] = v
+    
+    return f
+
+def data_record_from_h5py_group(
+    f:h5py.File
+):
+    data = f['data'][:]
+    stim_id = f.attrs['stim_id']
+    srate = int(f.attrs['srate'])
+
+    meta_info_grp = f['meta_info']
+    meta_info = {}
+    for k,v in meta_info_grp.attrs.items():
+        meta_info[k] = v
+    
+    for k,v in meta_info.items():
+        meta_info[k] = v
+    
+    return dict(
+        data = data, stim_id = stim_id, meta_info = meta_info, srate = srate
+    )

pytour-3.0.0.dev4/tour/package_manage.py

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Feb  6 08:33:37 2025
+
+@author: ShiningStone
+"""
+
+
+def check_import(package, name):
+    if package is None:
+        raise ImportError(f'{name} is failed to be imported')
+    return package
+    

pytour-3.0.0.dev4/tour/vis.py

@@ -0,0 +1,187 @@
+import mne
+import numpy as np
+from matplotlib import pyplot as plt
+from matplotlib import gridspec
+
+
+def plot_data(
+    data,
+    fs = 64,
+    times = None,
+    title = '',
+    chan_idx = None,
+    time_intvl = None,
+    units = 'a.u.',
+    montage = None,
+    mode = 'joint',
+    tmin = 0,
+    
+    **kwargs
+):
+    data = np.array(data)
+    ifAx = False
+    if montage is None:
+        montage = mne.channels.make_standard_montage('biosemi128')
+        chnames_map = dict(
+            C17 = 'Fpz',
+            # C21 = 'Fz',
+            # A1 = 'Cz',
+            D23 = 'T7',
+            B26 = 'T8',
+            # A19 = 'Pz',
+            A23 = 'Oz'
+        )
+
+        for k,v in chnames_map.items():
+            montage.ch_names[montage.ch_names.index(k)] = v
+
+    chNames = montage.ch_names
+    
+    # print(chNames)
+    try:
+        info = mne.create_info(chNames, fs,ch_types = 'eeg', montage = montage)
+    except:
+        info = mne.create_info(chNames, fs,ch_types = 'eeg')
+        info.set_montage(montage = montage)
+    
+    kwargs['sensors'] = False if 'sensors' not in kwargs else kwargs['sensors']
+    kwargs['res'] = 256 if 'res' not in kwargs else kwargs['res']
+    kwargs['outlines'] ='head' if 'outlines' not in kwargs else  kwargs['outlines']
+    show_names = kwargs.get('show_names', False)
+    if 'show_names' in kwargs:
+        del kwargs['show_names']
+    if show_names:
+        names = montage.ch_names
+    else:
+        names = None
+    ts_args = kwargs.get('ts_args', None)
+    
+    if time_intvl is not None:
+        time_intvl = np.array(time_intvl)
+        if time_intvl.ndim == 1:
+            time_intvl = time_intvl[None,...]
+        # print(time_intvl)
+        #calculate the intersted time point and average time window
+        average_window = time_intvl[:,1] - time_intvl[:,0]
+        timepoint = time_intvl.mean(1)
+    else:
+        average_window = None
+    
+    chanMask = None
+    if chan_idx is not None:
+        chanMask = np.zeros(data.shape,dtype = bool)
+        for i in chan_idx:
+            chanMask[i] = True
+    
+    kwargs['cmap'] = plt.get_cmap("bwr") if 'cmap' not in kwargs else kwargs['cmap']
+    kwargs['show'] = False if 'show' not in kwargs else kwargs['show']
+    
+    maskParam = dict(
+        marker='o', 
+        markerfacecolor='w', 
+        markeredgecolor='k',
+        linewidth=0, 
+        markersize=8
+    )
+    
+    maskParam2_default = dict(
+        marker='o', 
+        markerfacecolor='w', 
+        markeredgecolor='k',
+        linewidth=0, 
+        markersize=4
+    )
+    maskParam2 = kwargs.get('maskParam', maskParam2_default)
+    if 'maskParam' in kwargs:
+        del kwargs['maskParam']
+    
+    if data.ndim == 2:
+
+        default_ts_args={
+            "units": units, 
+            "scalings": dict(eeg=1),
+            "highlight": time_intvl,
+        }
+
+        if ts_args is not None:
+            default_ts_args.update(ts_args)
+
+
+        mneW = mne.EvokedArray(data,info, tmin = tmin)
+        if montage is not None:
+            mneW.set_montage(montage)
+        
+        if times is None:
+            if time_intvl is None:
+                if mode == 'joint':
+                    times = 'peaks'
+                else:
+                    times = 'auto'
+            else:
+                times = timepoint
+        
+        if mode == 'joint':
+            print(default_ts_args)
+            fig = mneW.plot_joint(
+                times = times,
+                topomap_args=dict(
+                    scalings = 1,
+                    mask = chanMask,
+                    mask_params= maskParam,
+                    average = average_window
+                ),
+                ts_args = default_ts_args,
+                show = kwargs.get('show', True),
+                title = title
+            )
+        else:
+            fig = mneW.plot_topomap(
+                times = times,
+                time_unit='s',
+                scalings = 1,
+                title = title,
+                units = units,
+                cbar_fmt='%3.3f',
+                mask = chanMask,
+                mask_params= maskParam2, 
+                colorbar=False,
+                # names = None,
+                **kwargs
+            )
+
+
+    elif data.ndim == 1:
+        if 'ax' in kwargs:
+            ax1 = kwargs['ax']
+            del kwargs['ax']
+            ifAx = True
+        else:
+            fig = plt.figure(tight_layout=True)
+            gridspec_kw={'width_ratios': [19, 1]}
+            gs = gridspec.GridSpec(4, 2,**gridspec_kw)
+            ax1 = fig.add_subplot(gs[:, 0])
+            ax2 = fig.add_subplot(gs[1:3, 1])
+        # print('contours')
+        im,cm = mne.viz.plot_topomap(
+            data.squeeze(),
+            info,
+            axes = ax1,
+            mask = chanMask, 
+            names = names,
+            mask_params= maskParam2,
+            sphere = 'eeglab',
+            contours = 2,
+            **kwargs
+        )
+        # cbar_ax = fig.add_axes([ax_x_start, ax_y_start, ax_x_width, ax_y_height])
+        if not ifAx:
+            clb = fig.colorbar(im, cax=ax2)
+            clb.ax.set_title(units,fontsize=10) # title on top of colorbar
+            fig.suptitle(title)
+    else:
+        raise NotImplementedError
+    
+    if not ifAx:
+        return fig
+    else:
+        return im