diff --git a/src/eeg_research/system/bids_selector.py b/src/eeg_research/system/bids_selector.py index cba8b05..384ca70 100644 --- a/src/eeg_research/system/bids_selector.py +++ b/src/eeg_research/system/bids_selector.py @@ -31,6 +31,109 @@ class that would be less strict. class BidsValidationError(Exception): pass +def set_errors(object, value: pd.DataFrame): + if hasattr(object, 'errors'): + delattr(object, 'errors') + if hasattr(object, '_errors'): + delattr(object, '_errors') + + setattr(object, '_errors', value) + +def set_database(object, value: pd.DataFrame): + if hasattr(object, 'database'): + delattr(object, 'database') + if hasattr(object, '_database'): + delattr(object, '_database') + + setattr(object, '_database', value) + +def merge_error_logs(self, other): + """Merge error logs efficiently.""" + if self._errors.empty and other._errors.empty: + return self._errors + + return pd.concat([ + self._errors, + other._errors.loc[~other._errors.index.isin(self._errors.index)] + ], copy=False) + +def is_all_columns_valid(database: pd.DataFrame) -> bool: + valid_columns = { + 'root', + 'subject', + 'session', + 'datatype', + 'task', + 'run', + 'acquisition', + 'description', + 'suffix', + 'extension', + 'atime', + 'mtime', + 'ctime', + 'filename' + } + database_columns = set(database.columns) + return valid_columns.issubset(database_columns) + +def has_all_filenames_valid(database: pd.DataFrame) -> bool: + return database['filename'].apply(validate_bids_file).all() + +def purify_database(database: pd.DataFrame) -> pd.DataFrame: + return database[database['filename'].apply(validate_bids_file)] + +def get_invalid_columns(database: pd.DataFrame) -> List[str]: + valid_columns = { + 'root', + 'subject', + 'session', + 'datatype', + 'task', + 'run', + 'acquisition', + 'description', + 'suffix', + 'extension', + 'atime', + 'mtime', + 'ctime', + 'filename' + } + database_columns = set(database.columns) + return list(database_columns - valid_columns) + +def get_invalid_filenames(database: pd.DataFrame) -> List[str]: + return database[~database['filename'].apply(validate_bids_file)] + + +def prepare_for_operations(object1, object2): + """Prepare objects for set operations and validate them.""" + conditions = ( + isinstance(object1, BidsArchitecture), + isinstance(object1, pd.DataFrame), + isinstance(object1, set), + isinstance(object2, BidsArchitecture), + isinstance(object2, pd.DataFrame), + isinstance(object2, set), + ) + if not any(conditions): + raise ValueError(f"Can't perform with {object1.__class__.__name__} and" + f" {object2.__class__.__name__}") + + if isinstance(object2, pd.DataFrame): + return object2.index + elif isinstance(object2, BidsArchitecture): + if not is_all_columns_valid(object2._database): + raise ValueError(f"{object2.__class__.__name__} has invalid columns: " + f"{get_invalid_columns(object2._database)}") + + if not has_all_filenames_valid(object2._database): + raise ValueError(f"{object2.__class__.__name__} has invalid filenames: " + f"{get_invalid_filenames(object2._database)}") + + return object2._database.index + return object2 # If it's already a set def validate_bids_file(file: Path) -> bool: """Validate the BIDS filename and pathname. @@ -44,15 +147,21 @@ def validate_bids_file(file: Path) -> bool: Raises: BidsValidationError: If validation fails """ - # Define BIDS rules - valid_keys = {"sub", "ses", "task", "acq", "run", "recording", "desc"} + valid_keys = {"sub", + "ses", + "task", + "acq", + "run", + "recording", + "desc", + "space"} + valid_datatype_pattern = re.compile(r"^[a-z0-9]+$") key_value_pattern = re.compile(r"(?P[a-zA-Z0-9]+)-(?P[a-zA-Z0-9]+)") path_pattern = re.compile(r"(sub|ses)-[\w\d]+") errors = [] - # Parse file structure filename = os.fspath(file.name) if file.suffix else None if filename: bids_path_parts = file.parent.parts[-3:] @@ -110,7 +219,7 @@ def validate_bids_file(file: Path) -> bool: bids_path_parts[0].split('-')[1] if '-' in bids_path_parts[0] else None ) path_session = ( - bids_path_parts[1].split('-')[1] if '-' in bids_path_parts[2] else None + bids_path_parts[1].split('-')[1] if '-' in bids_path_parts[1] else None ) filename_entities = {} @@ -295,7 +404,6 @@ def _make_basename(self) -> str: """ components = [f"sub-{self.subject}", f"ses-{self.session}"] - # Optional entities in BIDS-specified order if self.task: components.append(f"task-{self.task}") if self.acquisition: @@ -349,24 +457,20 @@ def from_filename(cls, file: Union[str, Path]) -> "BidsPath": """ if isinstance(file, str): file = Path(file) - - # Parse BIDS entities from filename + + cls._check_filename(cls,file) entities: Dict[str, Optional[str]] = {} - # Extract path components if len(file.parts) > 2: entities["datatype"] = file.parts[-2] - # Already normalized since we're extracting from BIDS structure entities["subject"] = file.parts[-3].split("-")[1] if len(file.parts) > 3: entities["session"] = file.parts[-4].split("-")[1] - # Parse filename components name_parts = file.stem.split("_") for part in name_parts: if "-" in part: key, value = part.split("-", 1) - # Values are already normalized since we're parsing from BIDS format if key == "sub": entities["subject"] = value elif key == "ses": @@ -520,6 +624,88 @@ def __init__( extension=extension or ".*", ) self._database: Optional[pd.DataFrame] = None + self._errors: Optional[pd.DataFrame] = None + def __repr__(self) -> str: + if hasattr(self, '_database'): + representation = f"BidsArchitecture: {self._database.shape[0]} files, "\ + f"{( + self._errors.shape[0] + )} errors, "\ + f"subjects: {len(self._database['subject'].unique())}, "\ + f"sessions: {len(self._database['session'].unique())}, "\ + f"datatypes: {len(self._database['datatype'].unique())}, "\ + f"tasks: {len(self._database['task'].unique())}" + else: + representation = "BidsArchitecture: No database created yet." + return representation + + def __str__(self) -> str: + return self.__repr__() + + def __len__(self) -> int: + return len(self.database) + + + def __getitem__(self, index: int) -> pd.DataFrame: + return self.database.iloc[index] + + def __setitem__(self, index: int, value: pd.DataFrame): + raise NotImplementedError("Setting items is not supported") + + def __iter__(self) -> Iterator[Path]: + return iter(self.database.iterrows()) + + def __add__(self, other: "BidsArchitecture") -> "BidsArchitecture": + """Union of two BidsArchitecture instances.""" + _ = prepare_for_operations(self, other) + new_instance = copy.copy(self) # Shallow copy is sufficient here + # Use concat with copy=False for better performance + set_database(new_instance, pd.concat( + [self._database, other._database], + copy=False, + verify_integrity=True + )) + set_errors(new_instance, merge_error_logs(self, other)) + return new_instance + + def __sub__(self, other: "BidsArchitecture") -> "BidsArchitecture": + """Difference of two BidsArchitecture instances.""" + indices_other = prepare_for_operations(self, other) + new_instance = copy.copy(self) # Shallow copy is sufficient + # Use index difference directly + remaining_indices = self._database.index.difference(indices_other) + set_database(new_instance, self._database.loc[remaining_indices]) + set_errors(new_instance, merge_error_logs(self, other)) + return new_instance + + def __and__(self, other: "BidsArchitecture") -> "BidsArchitecture": + """Intersection of two BidsArchitecture instances.""" + indices_other = prepare_for_operations(self, other) + new_instance = copy.copy(self) # Shallow copy is sufficient + # Use index intersection directly + common_indices = self._database.index.intersection(indices_other) + set_database(new_instance, self._database.loc[common_indices]) + set_errors(new_instance, merge_error_logs(self, other)) + return new_instance + + def __xor__(self, other: "BidsArchitecture") -> "BidsArchitecture": + """Symmetric difference of two BidsArchitecture instances.""" + indices_other = prepare_for_operations(self, other) + new_instance = copy.copy(self) # Shallow copy is sufficient + # Use index symmetric_difference directly + xor_indices = self._database.index.symmetric_difference(indices_other) + set_database(new_instance, self._database.loc[xor_indices]) + set_errors(new_instance, merge_error_logs(self, other)) + return new_instance + + + + @classmethod + def from_database(cls, filename: str | Path) -> "BidsArchitecture": + """Create BidsArchitecture instance from existing csv database.""" + df = pd.read_csv(filename) + + return cls @cached_property def database(self) -> pd.DataFrame: @@ -528,10 +714,19 @@ def database(self) -> pd.DataFrame: Returns: pd.DataFrame: Database containing all matching files and their BIDS entities """ - if self._database is None: - self._database = self._create_database() + self._database = self._create_database()[0] return self._database + @cached_property + def errors(self) -> pd.DataFrame: + """Get or create database of matching files. + + Returns: + pd.DataFrame: Database containing all matching files and their BIDS entities + """ + self._errors = self._create_database()[1] + return self._errors + def _get_unique_values(self, column: str) -> List[str]: """Get sorted unique non-None values for a given column. @@ -541,7 +736,7 @@ def _get_unique_values(self, column: str) -> List[str]: Returns: List[str]: Sorted list of unique non-None values """ - return sorted([elem for elem in self.database[column].unique() + return sorted([elem for elem in self._database[column].unique() if elem is not None]) @property @@ -625,6 +820,10 @@ def extensions(self) -> List[str]: """ return self._get_unique_values('extension') + def create_database_and_error_log(self) -> "BidsArchitecture": + self._database, self._errors = self._create_database() + return self + def _create_database(self) -> pd.DataFrame: """Scan filesystem and build DataFrame of matching files. @@ -632,6 +831,7 @@ def _create_database(self) -> pd.DataFrame: pd.DataFrame: DataFrame containing all matching files and their BIDS entities """ database_keys = [ + "inode", "root", "subject", "session", @@ -649,6 +849,10 @@ def _create_database(self) -> pd.DataFrame: ] data: Dict[str, List[Any]] = {key: [] for key in database_keys} + error_flags: Dict[str, List[bool]] = {'filename': [], + 'error_type': [], + 'error_message': [], + 'inode': []} pattern = self._path_handler.filename for file in self.root.rglob(pattern): @@ -664,16 +868,39 @@ def _create_database(self) -> pd.DataFrame: data[key].append(value) file_stats = file.stat() + data["inode"].append(int(file_stats.st_ino)) data["atime"].append(int(file_stats.st_atime)) data["mtime"].append(int(file_stats.st_mtime)) data["ctime"].append(int(file_stats.st_ctime)) data["filename"].append(file) - except BidsValidationError: - warn(f"Skipping invalid BIDS file: {file}") + + except Exception as e: + error_flags['filename'].append(file) + error_flags['error_type'].append(e.__class__.__name__) + error_flags['error_message'].append(str(e)) + error_flags['inode'].append(file.stat().st_ino) continue - return pd.DataFrame(data) + data_df = pd.DataFrame( + data, + index=data['inode'], + columns=[key for key in database_keys if key != 'inode'] + ) + error_df = pd.DataFrame( + error_flags, + index=error_flags['inode'], + columns=[key for key in error_flags.keys() if key != 'inode'] + ) + return data_df, error_df + + def print_errors_log(self): + if self.errors.empty: + print("No errors found") + else: + print(f"Number of files: {len(self.errors)}") + print(f"Error types: {self.errors['error_type'].unique()}") + def _get_range( self, dataframe_column: pd.core.series.Series, @@ -757,48 +984,105 @@ def _perform_selection( else: return self._get_single_loc(dataframe_column, value) - def select(self, **kwargs) -> "BidsArchitecture": - """Select files from database based on BIDS entities. - - Args: - **kwargs: Entity criteria to match (e.g., subject="001", task="rest") - - Returns: - New BidsArchitecture instance with filtered database + def _create_mask(self, **kwargs): + """Create boolean mask for filtering DataFrame using index-based operations. - Raises: - ValueError: If an invalid selection key is provided + Optimized version that leverages DataFrame indexing by inode and reduces + function calls by operating on index sets where possible. """ - valid_keys = [ + valid_keys = { "subject", "session", "datatype", "task", "run", "acquisition", "description", "suffix", "extension" - ] + } - # Validate keys - for key in kwargs: - if key not in valid_keys: - raise ValueError(f"Invalid selection key: {key}") + # Validate keys upfront + invalid_keys = set(kwargs.keys()) - valid_keys + if invalid_keys: + raise ValueError(f"Invalid selection keys: {invalid_keys}") - # Create new instance - new_instance = copy.deepcopy(self) - - # Build combined mask for all conditions - mask = pd.Series(True, index=self.database.index) + # Start with all inodes + valid_inodes = set(self._database.index) for key, value in kwargs.items(): - if value is not None: - if isinstance(value, list): - mask &= self.database[key].isin(value) - elif isinstance(value, str): - value = value.strip() - if value: # Skip empty strings - mask &= self._perform_selection(self.database[key], value) + if value is None: + continue + + if isinstance(value, list): + # Get inodes matching any value in the list + matching_inodes = set(self._database[self._database[key].isin(value)].index) + valid_inodes &= matching_inodes + continue + + if not isinstance(value, str): + continue + + value = value.strip() + if not value: + continue + + col = self._database[key] + + # Handle numerical range queries more efficiently + if '-' in value and self._is_numerical(col): + start, stop = value.split('-') + if start.isdigit() or start == '*': + if stop.isdigit() or stop == '*': + # Convert column to numeric once + col_numeric = pd.to_numeric(col, errors='coerce') + + start_val = int(start) if start.isdigit() else col_numeric.min() + stop_val = int(stop) if stop.isdigit() else col_numeric.max() + + # Get inodes for rows within range + range_mask = (col_numeric >= start_val) & (col_numeric <= stop_val) + matching_inodes = set(self._database[range_mask].index) + valid_inodes &= matching_inodes + + # Direct equality comparison using index operations + matching_inodes = set(self._database[col == value].index) + valid_inodes &= matching_inodes + + # Convert final set of inodes to boolean mask + return self._database.index.isin(valid_inodes) + + def select(self, inplace: bool = False, **kwargs) -> "BidsArchitecture": + """Select files from database based on BIDS entities. - if hasattr(new_instance, 'database'): - delattr(new_instance, 'database') - setattr(new_instance, - 'database', - self.database[mask].copy() - ) + Args: + inplace: If True, modify the current instance. If False, return a new instance. + **kwargs: BIDS entities to filter by + + Returns: + BidsArchitecture: Filtered instance + """ + mask = self._create_mask(**kwargs) + if inplace: + set_database(self, self._database.loc[mask]) + return self + + new_instance = copy.deepcopy(self) + set_database(new_instance, self._database.loc[mask]) + return new_instance + + def remove(self, inplace: bool = False, **kwargs) -> "BidsArchitecture": + """Remove files from database based on BIDS entities. + Args: + inplace: If True, modify the current instance. If False, return a new instance. + **kwargs: BIDS entities to filter by + + Returns: + BidsArchitecture: Filtered instance + """ + mask = self._create_mask(**kwargs) + if inplace: + set_database(self, self._database.loc[~mask]) + return self + + new_instance = copy.deepcopy(self) + set_database(new_instance, self._database.loc[~mask]) return new_instance + + + + diff --git a/src/eeg_research/system/test_lab.ipynb b/src/eeg_research/system/test_lab.ipynb index d3f3695..d21d72e 100644 --- a/src/eeg_research/system/test_lab.ipynb +++ b/src/eeg_research/system/test_lab.ipynb @@ -14,7 +14,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 41, "metadata": {}, "outputs": [], "source": [ @@ -32,7 +32,110 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "architecture.database.to_csv('test_database.csv')" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "# Find subjects with both session 1 and session 2\n", + "df = architecture.database\n", + "subjects_with_both_sessions = df.groupby('subject')['task'].nunique()\n", + "\n", + "subjects_with_both_sessions = subjects_with_both_sessions[subjects_with_both_sessions == 2].index\n", + "\n", + "\n", + "\n", + "# Filter the dataframe to include only these subjects\n", + "\n", + "df_filtered = df[df['subject'].isin(subjects_with_both_sessions)]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "task\n", + "checker 1\n", + "dme 2\n", + "dmh 2\n", + "inscapes 1\n", + "monkey1 2\n", + "monkey2 2\n", + "monkey5 2\n", + "peer 1\n", + "rest 1\n", + "tp 2\n", + "Name: run, dtype: int64" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.groupby('task')['run'].nunique()" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_3015282/2297978126.py:5: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.\n", + " plt.gca().set_xticklabels(architecture.database[x].unique(),rotation = 45)\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Task')" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "x = 'task'\n", + "y = 'filename'\n", + "plt.bar(architecture.database[x].unique(),df.groupby(x)[y].nunique())\n", + "plt.gca().set_xticklabels(architecture.database[x].unique(),rotation = 45)\n", + "plt.ylabel(y.capitalize())\n", + "plt.xlabel(x.capitalize())" + ] + }, + { + "cell_type": "code", + "execution_count": 40, "metadata": {}, "outputs": [ { @@ -56,11 +159,10 @@ " \n", " \n", " \n", + " \n", " root\n", " subject\n", - " session\n", " datatype\n", - " task\n", " run\n", " acquisition\n", " description\n", @@ -71,263 +173,258 @@ " ctime\n", " filename\n", " \n", - " \n", - " \n", " \n", - " 0\n", - " /data2/Projects/eeg_fmri_natview/derivatives\n", - " 01\n", - " 01\n", - " eeg\n", - " rest\n", - " 01\n", - " None\n", - " GfpBk\n", - " eeg\n", - " .pkl\n", - " 1733527515\n", - " 1733583482\n", - " 1733583482\n", - " /data2/Projects/eeg_fmri_natview/derivatives/s...\n", - " \n", - " \n", - " 1\n", - " /data2/Projects/eeg_fmri_natview/derivatives\n", - " 01\n", - " 01\n", - " eeg\n", - " monkey1\n", - " 02\n", - " None\n", - " GfpBk\n", - " eeg\n", - " .pkl\n", - " 1733527888\n", - " 1733590067\n", - " 1733590067\n", - " /data2/Projects/eeg_fmri_natview/derivatives/s...\n", - " \n", - " \n", - " 2\n", - " /data2/Projects/eeg_fmri_natview/derivatives\n", - " 01\n", - " 01\n", - " eeg\n", - " checker\n", - " 01\n", - " None\n", - " CustomGfpBk\n", - " eeg\n", - " .pkl\n", - " 1733528208\n", - " 1733580755\n", - " 1733580755\n", - " /data2/Projects/eeg_fmri_natview/derivatives/s...\n", - " \n", - " \n", - " 3\n", - " /data2/Projects/eeg_fmri_natview/derivatives\n", - " 01\n", - " 01\n", - " eeg\n", - " monkey1\n", - " 01\n", - " None\n", - " CustomGfpBk\n", - " eeg\n", - " .pkl\n", - " 1733526575\n", - " 1733589689\n", - " 1733589689\n", - " /data2/Projects/eeg_fmri_natview/derivatives/s...\n", - " \n", - " \n", - " 4\n", - " /data2/Projects/eeg_fmri_natview/derivatives\n", - " 01\n", - " 01\n", - " eeg\n", - " monkey1\n", - " 02\n", - " None\n", - " BandsGfpBk\n", - " eeg\n", - " .pkl\n", - " 1733527889\n", - " 1733590068\n", - " 1733590068\n", - " /data2/Projects/eeg_fmri_natview/derivatives/s...\n", + " session\n", + " task\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", + " \n", + " \n", " \n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", + " 01\n", + " checker\n", + " 22\n", + " 22\n", + " 22\n", + " 22\n", + " 0\n", + " 22\n", + " 22\n", + " 22\n", + " 22\n", + " 22\n", + " 22\n", + " 22\n", " \n", " \n", - " 2336\n", - " /data2/Projects/eeg_fmri_natview/derivatives\n", - " 19\n", - " 02\n", - " eeg\n", - " checker\n", - " 01\n", - " None\n", - " BandsEnv\n", - " eeg\n", - " .pkl\n", - " 1732032404\n", - " 1732224976\n", - " 1733496178\n", - " /data2/Projects/eeg_fmri_natview/derivatives/s...\n", + " rest\n", + " 22\n", + " 22\n", + " 22\n", + " 22\n", + " 0\n", + " 22\n", + " 22\n", + " 22\n", + " 22\n", + " 22\n", + " 22\n", + " 22\n", " \n", " \n", - " 2337\n", - " /data2/Projects/eeg_fmri_natview/derivatives\n", - " 19\n", - " 02\n", - " eeg\n", - " rest\n", - " 01\n", - " None\n", - " BandsEnv\n", - " eeg\n", - " .pkl\n", - " 1732033286\n", - " 1732224296\n", - " 1733496178\n", - " /data2/Projects/eeg_fmri_natview/derivatives/s...\n", + " 02\n", + " checker\n", + " 17\n", + " 17\n", + " 17\n", + " 17\n", + " 0\n", + " 17\n", + " 17\n", + " 17\n", + " 17\n", + " 17\n", + " 17\n", + " 17\n", " \n", " \n", - " 2338\n", - " /data2/Projects/eeg_fmri_natview/derivatives\n", - " 19\n", - " 02\n", - " eeg\n", - " rest\n", - " 01\n", - " None\n", - " BandsEnvBk\n", - " eeg\n", - " .pkl\n", - " 1732216150\n", - " 1733582320\n", - " 1733582320\n", - " /data2/Projects/eeg_fmri_natview/derivatives/s...\n", + " rest\n", + " 17\n", + " 17\n", + " 17\n", + " 17\n", + " 0\n", + " 17\n", + " 17\n", + " 17\n", + " 17\n", + " 17\n", + " 17\n", + " 17\n", " \n", " \n", - " 2339\n", - " /data2/Projects/eeg_fmri_natview/derivatives\n", - " 19\n", - " 02\n", - " eeg\n", - " checker\n", - " 01\n", - " None\n", - " BandsEnvBk\n", - " eeg\n", - " .pkl\n", - " 1732217492\n", - " 1733580557\n", - " 1733580557\n", - " /data2/Projects/eeg_fmri_natview/derivatives/s...\n", + " 03\n", + " checker\n", + " 1\n", + " 1\n", + " 1\n", + " 1\n", + " 0\n", + " 1\n", + " 1\n", + " 1\n", + " 1\n", + " 1\n", + " 1\n", + " 1\n", " \n", " \n", - " 2340\n", - " /data2/Projects/eeg_fmri_natview/derivatives\n", - " 19\n", - " 02\n", - " eeg\n", - " rest\n", - " 01\n", - " None\n", - " RawBk\n", - " eeg\n", - " .pkl\n", - " 1732216144\n", - " 1733582296\n", - " 1733582296\n", - " /data2/Projects/eeg_fmri_natview/derivatives/s...\n", + " rest\n", + " 1\n", + " 1\n", + " 1\n", + " 1\n", + " 0\n", + " 1\n", + " 1\n", + " 1\n", + " 1\n", + " 1\n", + " 1\n", + " 1\n", " \n", " \n", "\n", - "

2341 rows × 14 columns

\n", "" ], "text/plain": [ - " root subject session datatype \\\n", - "0 /data2/Projects/eeg_fmri_natview/derivatives 01 01 eeg \n", - "1 /data2/Projects/eeg_fmri_natview/derivatives 01 01 eeg \n", - "2 /data2/Projects/eeg_fmri_natview/derivatives 01 01 eeg \n", - "3 /data2/Projects/eeg_fmri_natview/derivatives 01 01 eeg \n", - "4 /data2/Projects/eeg_fmri_natview/derivatives 01 01 eeg \n", - "... ... ... ... ... \n", - "2336 /data2/Projects/eeg_fmri_natview/derivatives 19 02 eeg \n", - "2337 /data2/Projects/eeg_fmri_natview/derivatives 19 02 eeg \n", - "2338 /data2/Projects/eeg_fmri_natview/derivatives 19 02 eeg \n", - "2339 /data2/Projects/eeg_fmri_natview/derivatives 19 02 eeg \n", - "2340 /data2/Projects/eeg_fmri_natview/derivatives 19 02 eeg \n", - "\n", - " task run acquisition description suffix extension atime \\\n", - "0 rest 01 None GfpBk eeg .pkl 1733527515 \n", - "1 monkey1 02 None GfpBk eeg .pkl 1733527888 \n", - "2 checker 01 None CustomGfpBk eeg .pkl 1733528208 \n", - "3 monkey1 01 None CustomGfpBk eeg .pkl 1733526575 \n", - "4 monkey1 02 None BandsGfpBk eeg .pkl 1733527889 \n", - "... ... .. ... ... ... ... ... \n", - "2336 checker 01 None BandsEnv eeg .pkl 1732032404 \n", - "2337 rest 01 None BandsEnv eeg .pkl 1732033286 \n", - "2338 rest 01 None BandsEnvBk eeg .pkl 1732216150 \n", - "2339 checker 01 None BandsEnvBk eeg .pkl 1732217492 \n", - "2340 rest 01 None RawBk eeg .pkl 1732216144 \n", + " root subject datatype run acquisition description \\\n", + "session task \n", + "01 checker 22 22 22 22 0 22 \n", + " rest 22 22 22 22 0 22 \n", + "02 checker 17 17 17 17 0 17 \n", + " rest 17 17 17 17 0 17 \n", + "03 checker 1 1 1 1 0 1 \n", + " rest 1 1 1 1 0 1 \n", "\n", - " mtime ctime \\\n", - "0 1733583482 1733583482 \n", - "1 1733590067 1733590067 \n", - "2 1733580755 1733580755 \n", - "3 1733589689 1733589689 \n", - "4 1733590068 1733590068 \n", - "... ... ... \n", - "2336 1732224976 1733496178 \n", - "2337 1732224296 1733496178 \n", - "2338 1733582320 1733582320 \n", - "2339 1733580557 1733580557 \n", - "2340 1733582296 1733582296 \n", - "\n", - " filename \n", - "0 /data2/Projects/eeg_fmri_natview/derivatives/s... \n", - "1 /data2/Projects/eeg_fmri_natview/derivatives/s... \n", - "2 /data2/Projects/eeg_fmri_natview/derivatives/s... \n", - "3 /data2/Projects/eeg_fmri_natview/derivatives/s... \n", - "4 /data2/Projects/eeg_fmri_natview/derivatives/s... \n", - "... ... \n", - "2336 /data2/Projects/eeg_fmri_natview/derivatives/s... \n", - "2337 /data2/Projects/eeg_fmri_natview/derivatives/s... \n", - "2338 /data2/Projects/eeg_fmri_natview/derivatives/s... \n", - "2339 /data2/Projects/eeg_fmri_natview/derivatives/s... \n", - "2340 /data2/Projects/eeg_fmri_natview/derivatives/s... \n", - "\n", - "[2341 rows x 14 columns]" + " suffix extension atime mtime ctime filename \n", + "session task \n", + "01 checker 22 22 22 22 22 22 \n", + " rest 22 22 22 22 22 22 \n", + "02 checker 17 17 17 17 17 17 \n", + " rest 17 17 17 17 17 17 \n", + "03 checker 1 1 1 1 1 1 \n", + " rest 1 1 1 1 1 1 " ] }, - "execution_count": 2, + "execution_count": 40, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "architecture.database" + "architecture.database.groupby([x,'task']).count()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "s = architecture.database.groupb" ] }, {