from .database.database import Cells, Datasets, CellDatasetMap, Subjects, SubjectProperties, SubjectDatasetMap, Stimuli, Repros import numpy as np def _safe_get_val(dictionary:dict, key, default=None): return dictionary[key] if key in dictionary.keys() else default class Cell: def __init__(self, cell_id=None, tuple=None): if tuple: self.__tuple = tuple elif cell_id: pattern = "cell_id like '{0:s}'".format(cell_id) cells = (Cells & pattern) assert (len(cells) == 1), "Cell id does not exist or is not unique!" self.__tuple = cells.fetch(as_dict=True)[0] else: print("Empty Cell, not linked to any database entry!") @property def cell_id(self): return self.__tuple["cell_id"] if "cell_id" in self.__tuple.keys() else "" @property def cell_type(self): return self.__tuple["cell_type"] if "cell_type" in self.__tuple.keys() else "" @property def firing_rate(self): return self.__tuple["firing_rate"] if "firing_rate" in self.__tuple.keys() else 0.0 @property def location(self): keys = ["structure", "region", "subregion", "depth", "lateral_pos", "transversal_section"] loc = {} for k in keys: if k in self.__tuple.keys(): loc[k] = self.__tuple[k] else: loc[k] = "" return loc @property def subject(self): return Subject(tuple=(Subjects & {"subject_id": self.__tuple["subject_id"]}).fetch(limit=1, as_dict=True)[0]) @property def repro_runs(self): repros = (Repros & "cell_id = '%s'" % self.cell_id) return [RePro(tuple=r) for r in repros] @staticmethod def celltypes(): return np.unique(Cells.fetch("cell_type")) @staticmethod def find_cells(cell_type=None, species=None, quality="good"): cs = Cells * CellDatasetMap * Datasets * Subjects if cell_type: cs = cs & "cell_type like '{0:s}'".format(cell_type) if species: cs = cs & "species like '%{0:s}%'".format(species) if quality: cs = cs & "quality like '{0:s}'".format(quality) return [Cell(tuple=c) for c in cs] def __str__(self): str = "" str += "Cell: %s \t type: %s\n"%(self.cell_id, self.cell_type) return str class Dataset: def __init__(self, dataset_id=None, tuple=None): if tuple: self.__tuple = tuple elif dataset_id: pattern = "dataset_id like '{0:s}'".format(dataset_id) dsets = (Datasets & pattern) assert(len(dsets) == 1), "Dataset name is not unique!" self.__tuple = dsets.fetch(limit=1)[0] else: print("Empty dataset, not linked to any database entry!") @property def dataset_id(self): return self.__tuple["dataset_id"] @property def experimenter(self): return self.__tuple["experimenter"] @property def recording_date(self): return self.__tuple["recording_date"] @property def recording_duration(self): return self.__tuple["duration"] @property def quality(self): return self.__tuple["quality"] @property def has_nix(self): return self.__tuple["has_nix"] @property def comment(self): return self.__tuple["comment"] @property def data_source(self): return self.__tuple["data_source"] @property def setup(self): return self.__tuple["setup"] @property def cells(self): cs = (Cells * (CellDatasetMap & self.__tuple)) return [Cell(tuple=c) for c in cs] @property def subjects(self): subjs = (Subjects * (SubjectDatasetMap & self.__tuple)) return [Subject(tuple=s) for s in subjs] @staticmethod def find_datasets(min_duration=None, experimenter=None, quality=None): dsets = Datasets if min_duration: dsets = dsets & "duration > %.2f" % min_duration if experimenter: dsets = dsets & "experimenter like '%{0:s}%'".format(experimenter) if quality: dsets = dsets & "quality like '{0:s}'".format(quality) return [Dataset(tuple=d) for d in dsets] class RePro: def __init__(self, repro_id=None, tuple=None): if tuple: self.__tuple = tuple elif repro_id: repros = (RePro & "repro_id like '{0:s}'".format(repro_id)) assert (len(repros) == 1), "Repro id does not exist or is not unique!" self.__tuple = repros.fetch(limit=1, as_dict=True)[0] else: self.__tuple = {} print("Empty RePro, not linked to any database entry!") @property def repro_id(self): return _safe_get_val(self.__tuple, "repro_id", "") @property def run(self): return _safe_get_val(self.__tuple, "run", -1) @property def cell_id(self): return _safe_get_val(self.__tuple, "cell_id", "") @property def cell(self): return Cell(self.cell_id) @property def name(self): return _safe_get_val(self.__tuple, "repro_name", "") @property def settings(self): return _safe_get_val(self.__tuple, "settings", "") @property def start(self): return _safe_get_val(self.__tuple, "start", 0.0) @property def duration(self): return _safe_get_val(self.__tuple, "duration", 0.0) @property def stimuli(self): stims = Stimuli & "repro_id = '%s'" % self.repro_id & "cell_id = '%s'" % self.cell_id return [Stimulus(tuple=s) for s in stims] @staticmethod def find_repros(repro_name=None, cell_id=None, settings=None): repros = Repros & True if repro_name: repros = repros & "repro_name like '%{0:s}%'".format(repro_name) if cell_id: repros = repros & "cell_id = '%s'" % cell_id if settings: repros = repros & "settings like '%{0:s}%'".format(settings) return [RePro(tuple=r) for r in repros] class Stimulus: def __init__(self, stimulus_id=None, tuple=None): if tuple: self.__tuple = tuple elif stimulus_id: stims = Stimuli & "stimulus_id = '%s'" %stimulus_id assert(len(stims) == 1), "Stimulus_id does not exist or is not unique!" self.__tuple = stims.fetch(limit=1, as_dict=True)[0] else: print("Empty RePro, not linked to any database entry!") def __str__(self): str = "Stimulus %s: " % _safe_get_val(self.__tuple, "stimulus_id", "") str += "\nStart time/index: %0.4f/%i, duration: %.3f" % (_safe_get_val(self.__tuple, "start_time", 0.0), _safe_get_val(self.__tuple, "start_index", -1), _safe_get_val(self.__tuple, "duration", 0.0)) return str @property def settings(self): return _safe_get_val(self.__tuple, "settings", "") class Subject: def __init__(self, subject_id=None, tuple=None): if tuple: self.__tuple = tuple elif subject_id: self.__tuple = Subjects & "subject_id like '{0:s}'".format(subject_id).fetch()[0] else: self.__tuple = {} print("Empty Subject, not linked to any database entry!") @property def subject_id(self): return self.__tuple["subject_id"] @property def species(self): return self.__tuple["species"] @property def cells(self): cs = Cells & self.__tuple return [Cell(tuple=c) for c in cs] @property def properties(self): return (SubjectProperties & self.__tuple).fetch(as_dict=True) @staticmethod def find_subjects(species=None): subjs = Subjects & True if species: subjs = (Subjects & "species like '%{0:s}%'".format(species)) return [Subject(tuple=s) for s in subjs] @staticmethod def unique_species(): all_species = (Subjects & True).fetch("species") return np.unique(all_species) if __name__ == "__main__": from IPython import embed cell = Cell("2010-04-16-ak") embed()