pull latest development

Author: rodriguez-facundo

Dockerfile

@@ -1,7 +1,10 @@
 FROM metacell/jupyter-neuron:latest
-# Switch to non sudo, create a Python 3 virtual environment 
 USER $NB_USER
 
+ARG netpyneuiBranch=development 
+ENV netpyneuiBranch=${netpyneuiBranch}  
+RUN echo "$netpyneuiBranch";
+
 ARG INCUBATOR_VER=unknown
 RUN /bin/bash -c "INCUBATOR_VER=${INCUBATOR_VER} source activate snakes && pip install netpyne_ui"
 RUN /bin/bash -c "source activate snakes && jupyter nbextension enable --py jupyter_geppetto"
@@ -11,4 +14,13 @@ RUN /bin/bash -c "source activate snakes && jupyter nbextension enable --py widg
 WORKDIR /home/jovyan
 RUN git clone --branch CNS18 https://github.com/Neurosim-lab/netpyne_workspace
 WORKDIR /home/jovyan/netpyne_workspace
-CMD /bin/bash -c "source activate snakes && exec jupyter notebook --debug --NotebookApp.default_url=/geppetto --NotebookApp.token=''"
+
+# Uncomment to run travis using this Dockerfile
+# Clone the source code and creates a symlink to the test folder
+WORKDIR /home/jovyan/work
+RUN wget https://github.com/MetaCell/NetPyNE-UI/archive/$netpyneuiBranch.zip -q
+RUN unzip $netpyneuiBranch.zip 
+WORKDIR /home/jovyan/netpyne_workspace
+RUN ln -sfn /home/jovyan/work/NetPyNE-UI-$netpyneuiBranch/netpyne_ui/tests tests
+
+CMD /bin/bash -c "source activate snakes && exec jupyter notebook --debug --NotebookApp.default_url=/geppetto --NotebookApp.token='' --library=netpyne_ui"

MANIFEST.in

@@ -0,0 +1,11 @@
+# Include everything inside this folder
+graft netpyne_ui/geppetto/src/main/webapp/build
+
+# Include any of these resources at any level
+recursive-include netpyne_ui/geppetto *.png *.css *.woff *.woff2
+
+# Include any of these resources at any level
+recursive-include netpyne_ui/tests *.hoc
+
+# Include also root files (basically the extension)
+include netpyne_ui/*

netpyne_ui/netpyne_geppetto.py

@@ -227,21 +227,26 @@ def importModel(self, modelParameters):
         finally:
             os.chdir(owd)
 
-    def importCellTemplate(self, modelParameters, modFolder, compileMod):
+    def importCellTemplate(self, modelParameters):
         try:
-            # Get Current dir
-            owd = os.getcwd()
+            with redirect_stdout(sys.__stdout__):
+                rule = modelParameters["label"]
+                # Get Current dir
+                owd = os.getcwd()
 
-            self.compileModMechFiles(compileMod, modFolder)
+                conds = {} if rule not in self.netParams.cellParams else self.netParams.cellParams[rule]['conds']
 
-            # import cell template
-            self.netParams.importCellParams(**modelParameters)
-            
-            # convert fron netpyne.specs.dict to dict
-            rule = modelParameters["label"]
-            self.netParams.cellParams[rule] = self.netParams.cellParams[rule].todict()
+                self.compileModMechFiles(modelParameters["compileMod"], modelParameters["modFolder"])
 
-            return utils.getJSONReply()
+                del modelParameters["modFolder"]
+                del modelParameters["compileMod"]
+                # import cell template
+                self.netParams.importCellParams(**modelParameters, conds=conds)
+                
+                # convert fron netpyne.specs.dict to dict
+                self.netParams.cellParams[rule] = self.netParams.cellParams[rule].todict()
+
+                return utils.getJSONReply()
         except:
             return utils.getJSONError("Error while importing the NetPyNE cell template", sys.exc_info())
         finally:
@@ -337,6 +342,15 @@ def rename(self, path, oldValue,newValue):
                 newModel = re.sub("(['])(?:(?=(\\?))\2.)*?\1", lambda x:x.group(0).replace(oldValue,newValue, 1), model)
                 logging.debug("Rename funct - Model is "+model+" newModel is "+newModel)
                 jupyter_geppetto.synched_models[newModel]=synched_component
+        with redirect_stdout(sys.__stdout__):
+            if "popParams" in path:
+                self.propagate_field_rename("pop", newValue, oldValue)
+            elif "stimSourceParams" in path:
+                self.propagate_field_rename("source", newValue, oldValue)
+            elif "synMechParams" in path:
+                self.propagate_field_rename("synMech", newValue, oldValue)
+        
+        return 1
 
     def getPlotSettings(self, plot):
         if self.simConfig.analysis and plot in self.simConfig.analysis:
@@ -388,7 +402,7 @@ def getAvailableCellModels(self):
                 cm = self.netParams.popParams[p]['cellModel']
                 if cm not in cellModels:
                     cellModels.add(cm)
-        return cellModels
+        return list(cellModels)
 
     def getAvailableCellTypes(self):
         cellTypes = set([])
@@ -397,7 +411,7 @@ def getAvailableCellTypes(self):
                 ct = self.netParams.popParams[p]['cellType']
                 if ct not in cellTypes:
                     cellTypes.add(ct)
-        return cellTypes
+        return list(cellTypes)
 
     def getAvailableSections(self):
         sections = {}
@@ -427,29 +441,51 @@ def getAvailablePlots(self):
 
         return [plot for plot in plots if plot not in list(self.simConfig.analysis.keys())]
 
-    
+    def getInclude(self, model):
+        with redirect_stdout(sys.__stdout__):
+            if model in list(netpyne_geppetto.simConfig.analysis.keys()):
+                if 'include' in list(netpyne_geppetto.simConfig.analysis[model].keys()):
+                    return netpyne_geppetto.simConfig.analysis[model]['include']
+                else:
+                    return False
+            else:
+                return False
+
     def getGIDs(self):
         # pop sizes and gids returned in a dict
         out = {}
         with redirect_stdout(sys.__stdout__):
-          for key in self.netParams.popParams.keys():
-              if 'numCells' in self.netParams.popParams[key]:
-                  out[key] = self.netParams.popParams[key]['numCells']
-              else:
-                  out[key] = 0
-          
-          out['gids'] = int(np.sum([v for k, v in list(out.items())]))
-          
+            for key in self.netParams.popParams.keys():
+                if 'numCells' in self.netParams.popParams[key]:
+                    out[key] = self.netParams.popParams[key]['numCells']
+                else:
+                    out[key] = 0
+
+            out['gids'] = int(np.sum([v for k, v in list(out.items())]))
+
         return out
 
-    def deleteParam(self, paramToDel):
-        logging.debug("Checking if netParams."+paramToDel+" is not null")
-        if eval("self.netParams."+paramToDel) is not None:
-            exec("del self.netParams.%s" % (paramToDel))
-            logging.debug('Parameter netParams.'+paramToDel+' has been deleted')
-        else:
-            logging.debug('Parameter '+paramToDel+' is null, not deleted')
-        
+    def deleteParam(self, model, label):
+        try:
+            if isinstance(model, list): # just for cellParams
+                if len(model)==1:
+                    self.netParams.cellParams[model[0]]["secs"].pop(label)
+                elif len(model)==2:
+                    self.netParams.cellParams[model[0]]["secs"][model[1]]["mechs"].pop(label)
+                else:
+                    pass
+            else:
+                getattr(self.netParams, model).pop(label)
+                if "popParams" in model:
+                    self.propagate_field_rename("pop", None, label)
+                elif "stimSourceParams" in model:
+                    self.propagate_field_rename("source", None, label)
+                elif "synMechParams" in model:
+                    self.propagate_field_rename("synMech", None, label)
+            return True
+        except:
+            return False
+
     def validateFunction(self, functionString):
         return validateFunction(functionString, self.netParams.__dict__)
 
@@ -503,6 +539,86 @@ def header(title, spacer='-'):
         except:
             return utils.getJSONError("Error while importing the NetPyNE model", sys.exc_info())
 
+
+    def propagate(self, obj, label, cond, new, old):
+        for key in obj.keys():
+            if label in list(obj[key][cond].keys()):
+                if isinstance(obj[key][cond][label], str):
+                    if old==obj[key][cond][label]:
+                        if new=='' or new==None: 
+                            obj[key].pop(label) 
+                        else: 
+                            obj[key][cond][label] = new
+
+                elif isinstance(obj[key][cond][label], list):
+                    if old in obj[key][cond][label]:
+                        if new=='' or new==None:
+                            obj[key][cond][label] = [ value for value in obj[key][cond][label] if value!=old]
+                        else:
+                            obj[key][cond][label] = [ value if value!=old else new for value in obj[key][cond][label] ]
+                    if len(obj[key][cond][label])==0:
+                        obj[key][cond].pop(label)
+                else:
+                    pass
+
+    def propagate_field_rename(self, label, new, old):
+        def unique(label=label, old=old):
+            classes = []
+            for p in self.netParams.popParams:
+                if label in self.netParams.popParams[p]:
+                    classes.append(self.netParams.popParams[p][label])
+            if classes.count(old)>1:
+                return False
+            else:
+                return True
+
+        if label=='source':
+            self.propagate_stim_source_rename(new, old)
+            return True
+        elif label=='synMech':
+            self.propagate_syn_mech_rename(new, old)
+            return True
+        else:
+            if unique():    
+                for (model, cond) in [['cellParams','conds'], ['connParams', 'preConds'], ['connParams', 'postConds'], ['stimTargetParams', 'conds']]: 
+                    self.propagate(getattr(self.netParams, model), label, cond, new, old)
+                return True
+            else:
+                return False
+
+    def propagate_section_rename(self, new, old):
+        for label in self.netParams.cellParams:
+            if 'secs' in self.netParams.cellParams[label]:
+                for sec in self.netParams.cellParams[label]['secs']:
+                    if 'topol' in self.netParams.cellParams[label]['secs'][sec]:
+                        if 'parentSec' in self.netParams.cellParams[label]['secs'][sec]['topol']:
+                            if self.netParams.cellParams[label]['secs'][sec]['topol']['parentSec'] == old:
+                                if new == None:
+                                    self.netParams.cellParams[label]['secs'][sec]['topol'].pop('parentSec')
+                                else:
+                                    self.netParams.cellParams[label]['secs'][sec]['topol']['parentSec'] = new
+
+    def propagate_stim_source_rename(self, new, old):
+        for label in self.netParams.stimTargetParams:
+            if old==self.netParams.stimTargetParams[label]['source']:
+                if new==None:
+                    self.netParams.stimTargetParams[label].pop('source')
+                else:
+                    self.netParams.stimTargetParams[label]['source'] = new
+    
+    def propagate_syn_mech_rename(self, new, old):
+        for label in self.netParams.stimTargetParams:
+            if 'source' in self.netParams.stimTargetParams[label]:
+                if self.netParams.stimTargetParams[label]['source'] in self.netParams.stimSourceParams:
+                    if 'type' in self.netParams.stimSourceParams[self.netParams.stimTargetParams[label]['source']]:
+                        if self.netParams.stimSourceParams[self.netParams.stimTargetParams[label]['source']]['type']=='NetStim':        
+                            if old==self.netParams.stimTargetParams[label]['synMech']:
+                                if new==None:
+                                    self.netParams.stimTargetParams[label].pop('synMech')
+                                else:
+                                    self.netParams.stimTargetParams[label]['synMech'] = new
+
+
 logging.info("Initialising NetPyNE UI")
 netpyne_geppetto = NetPyNEGeppetto()
 logging.info("NetPyNE UI initialised")