separate front and backend classes, decrease safety settings

database.py

@@ -65,16 +65,76 @@ class Datasets(dj.Manual):
             sane = False
         return sane
 
+    @staticmethod
+    def datasets(min_duration=None, experimenter=None, quality=None):
+        dsets = Datasets
+        if min_duration:
+           dsets = dsets & "duration > %.2f" % min_duration
+        if experimenter:
+            dsets = dsets & dict(experimenter=experimenter)
+        if quality:
+            dsets = dsets & "quality like '{0:s}'".format(quality)
+        return [Dataset(tuple=d) for d in dsets]
+
+
+class Dataset:
+    def __init__(self, dataset_id=None, exact=False, tuple=None):
+        if tuple:
+            self.__tuple = tuple
+        elif dataset_id:
+            wildcard = "%" if not exact else ""
+            pattern = "dataset_id like '{0:s}{0:s}{0:s}'".format(wildcard, dataset_id, wildcard)
+            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 cells(self, restrictions:dict=None):
+    def dataset_id(self):
+        return self.__tuple["dataset_id"]
 
-        cs = (Cells & (CellDatasetMap & self) & restrictions).fetch()
-        return cs
+    @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, restrictions:dict=None):
-        subjs = (Subjects & (SubjectDatasetMap & self) & restrictions).fetch()
-        return subjs
+    def subjects(self):
+        subjs = (Subjects * (SubjectDatasetMap & self.__tuple))
+        return [Subject(tuple=s) for s in subjs]
 
 
 @schema
@@ -115,21 +175,16 @@ class Subjects(dj.Manual):
     def subjects(species=None):
         subjs = []
         if species:
-            subjs = (Subjects & "species like '%{0:s}%'".format(species)).fetch()
+            subjs = (Subjects & "species like '%{0:s}%'".format(species))
         else:
-            subjs = (Subjects & True).fetch()
-        return subjs
+            subjs = (Subjects & True)
+        return [Subject(tuple=s for s in subjs]
 
     @staticmethod
     def unique_species():
         all_species = (Subjects & True).fetch("species")
         return np.unique(all_species)
 
-    @property
-    def cells(self):
-        cs = Cells & self
-        return cs
-
     @property
     def properties(self):
         return (SubjectProperties & self).fetch1()
@@ -139,6 +194,31 @@ class Subjects(dj.Manual):
     #    retrun
 
 
+class Subject:
+    __tuple = {}
+
+    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:
+            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]
+
+
 @schema
 class SubjectDatasetMap(dj.Manual):
     definition = """
@@ -215,6 +295,22 @@ class Cells(dj.Manual):
             cs = cs & "quality like '{0:s}'".format(quality)
         return cs
 
+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 is not unique!"
+            self.__tuple = cells.fetch(as_dict=True)[0]
+        else:
+            print("Empty Cell, not linke to any database entry!")
+
+    @property
+    def cell_id(self):
+        return self.__tuple["cell_id"] if "cell_id" in self.__tuple.keys() else ""
+
 
 @schema
 class CellDatasetMap(dj.Manual):

dj_local_conf.json

@@ -5,7 +5,7 @@
     "loglevel": "DEBUG",
     "display.width": 14,
     "display.limit": 7,
-    "safemode": true,
+    "safemode": false,
     "database.user": "dj",
     "connection.init_function": null
 }